SIRIUS  7.2.5
Electronic structure library and applications
nlohmann_json.hpp
1 /*
2  __ _____ _____ _____
3  __| | __| | | | JSON for Modern C++
4 | | |__ | | | | | | version 3.9.1
5 |_____|_____|_____|_|___| https://github.com/nlohmann/json
6 
7 Licensed under the MIT License <http://opensource.org/licenses/MIT>.
8 SPDX-License-Identifier: MIT
9 Copyright (c) 2013-2019 Niels Lohmann <http://nlohmann.me>.
10 
11 Permission is hereby granted, free of charge, to any person obtaining a copy
12 of this software and associated documentation files (the "Software"), to deal
13 in the Software without restriction, including without limitation the rights
14 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
15 copies of the Software, and to permit persons to whom the Software is
16 furnished to do so, subject to the following conditions:
17 
18 The above copyright notice and this permission notice shall be included in all
19 copies or substantial portions of the Software.
20 
21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
22 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
24 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
25 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
26 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
27 SOFTWARE.
28 */
29 
30 #ifndef INCLUDE_NLOHMANN_JSON_HPP_
31 #define INCLUDE_NLOHMANN_JSON_HPP_
32 
33 #define NLOHMANN_JSON_VERSION_MAJOR 3
34 #define NLOHMANN_JSON_VERSION_MINOR 9
35 #define NLOHMANN_JSON_VERSION_PATCH 1
36 
37 #include <algorithm> // all_of, find, for_each
38 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
39 #include <functional> // hash, less
40 #include <initializer_list> // initializer_list
41 #include <iosfwd> // istream, ostream
42 #include <iterator> // random_access_iterator_tag
43 #include <memory> // unique_ptr
44 #include <numeric> // accumulate
45 #include <string> // string, stoi, to_string
46 #include <utility> // declval, forward, move, pair, swap
47 #include <vector> // vector
48 
49 // #include <nlohmann/adl_serializer.hpp>
50 
51 
52 #include <utility>
53 
54 // #include <nlohmann/detail/conversions/from_json.hpp>
55 
56 
57 #include <algorithm> // transform
58 #include <array> // array
59 #include <forward_list> // forward_list
60 #include <iterator> // inserter, front_inserter, end
61 #include <map> // map
62 #include <string> // string
63 #include <tuple> // tuple, make_tuple
64 #include <type_traits> // is_arithmetic, is_same, is_enum, underlying_type, is_convertible
65 #include <unordered_map> // unordered_map
66 #include <utility> // pair, declval
67 #include <valarray> // valarray
68 
69 // #include <nlohmann/detail/exceptions.hpp>
70 
71 
72 #include <exception> // exception
73 #include <stdexcept> // runtime_error
74 #include <string> // to_string
75 
76 // #include <nlohmann/detail/input/position_t.hpp>
77 
78 
79 #include <cstddef> // size_t
80 
81 namespace nlohmann
82 {
83 namespace detail
84 {
85 /// struct to capture the start position of the current token
86 struct position_t
87 {
88  /// the total number of characters read
89  std::size_t chars_read_total = 0;
90  /// the number of characters read in the current line
91  std::size_t chars_read_current_line = 0;
92  /// the number of lines read
93  std::size_t lines_read = 0;
94 
95  /// conversion to size_t to preserve SAX interface
96  constexpr operator size_t() const
97  {
98  return chars_read_total;
99  }
100 };
101 
102 } // namespace detail
103 } // namespace nlohmann
104 
105 // #include <nlohmann/detail/macro_scope.hpp>
106 
107 
108 #include <utility> // pair
109 // #include <nlohmann/thirdparty/hedley/hedley.hpp>
110 /* Hedley - https://nemequ.github.io/hedley
111  * Created by Evan Nemerson <evan@nemerson.com>
112  *
113  * To the extent possible under law, the author(s) have dedicated all
114  * copyright and related and neighboring rights to this software to
115  * the public domain worldwide. This software is distributed without
116  * any warranty.
117  *
118  * For details, see <http://creativecommons.org/publicdomain/zero/1.0/>.
119  * SPDX-License-Identifier: CC0-1.0
120  */
121 
122 #if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 13)
123 #if defined(JSON_HEDLEY_VERSION)
124  #undef JSON_HEDLEY_VERSION
125 #endif
126 #define JSON_HEDLEY_VERSION 13
127 
128 #if defined(JSON_HEDLEY_STRINGIFY_EX)
129  #undef JSON_HEDLEY_STRINGIFY_EX
130 #endif
131 #define JSON_HEDLEY_STRINGIFY_EX(x) #x
132 
133 #if defined(JSON_HEDLEY_STRINGIFY)
134  #undef JSON_HEDLEY_STRINGIFY
135 #endif
136 #define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x)
137 
138 #if defined(JSON_HEDLEY_CONCAT_EX)
139  #undef JSON_HEDLEY_CONCAT_EX
140 #endif
141 #define JSON_HEDLEY_CONCAT_EX(a,b) a##b
142 
143 #if defined(JSON_HEDLEY_CONCAT)
144  #undef JSON_HEDLEY_CONCAT
145 #endif
146 #define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b)
147 
148 #if defined(JSON_HEDLEY_CONCAT3_EX)
149  #undef JSON_HEDLEY_CONCAT3_EX
150 #endif
151 #define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c
152 
153 #if defined(JSON_HEDLEY_CONCAT3)
154  #undef JSON_HEDLEY_CONCAT3
155 #endif
156 #define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c)
157 
158 #if defined(JSON_HEDLEY_VERSION_ENCODE)
159  #undef JSON_HEDLEY_VERSION_ENCODE
160 #endif
161 #define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision))
162 
163 #if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR)
164  #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
165 #endif
166 #define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000)
167 
168 #if defined(JSON_HEDLEY_VERSION_DECODE_MINOR)
169  #undef JSON_HEDLEY_VERSION_DECODE_MINOR
170 #endif
171 #define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000)
172 
173 #if defined(JSON_HEDLEY_VERSION_DECODE_REVISION)
174  #undef JSON_HEDLEY_VERSION_DECODE_REVISION
175 #endif
176 #define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000)
177 
178 #if defined(JSON_HEDLEY_GNUC_VERSION)
179  #undef JSON_HEDLEY_GNUC_VERSION
180 #endif
181 #if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__)
182  #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__)
183 #elif defined(__GNUC__)
184  #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0)
185 #endif
186 
187 #if defined(JSON_HEDLEY_GNUC_VERSION_CHECK)
188  #undef JSON_HEDLEY_GNUC_VERSION_CHECK
189 #endif
190 #if defined(JSON_HEDLEY_GNUC_VERSION)
191  #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
192 #else
193  #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0)
194 #endif
195 
196 #if defined(JSON_HEDLEY_MSVC_VERSION)
197  #undef JSON_HEDLEY_MSVC_VERSION
198 #endif
199 #if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000)
200  #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100)
201 #elif defined(_MSC_FULL_VER)
202  #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10)
203 #elif defined(_MSC_VER)
204  #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0)
205 #endif
206 
207 #if defined(JSON_HEDLEY_MSVC_VERSION_CHECK)
208  #undef JSON_HEDLEY_MSVC_VERSION_CHECK
209 #endif
210 #if !defined(_MSC_VER)
211  #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0)
212 #elif defined(_MSC_VER) && (_MSC_VER >= 1400)
213  #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch)))
214 #elif defined(_MSC_VER) && (_MSC_VER >= 1200)
215  #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch)))
216 #else
217  #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor)))
218 #endif
219 
220 #if defined(JSON_HEDLEY_INTEL_VERSION)
221  #undef JSON_HEDLEY_INTEL_VERSION
222 #endif
223 #if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
224  #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE)
225 #elif defined(__INTEL_COMPILER)
226  #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0)
227 #endif
228 
229 #if defined(JSON_HEDLEY_INTEL_VERSION_CHECK)
230  #undef JSON_HEDLEY_INTEL_VERSION_CHECK
231 #endif
232 #if defined(JSON_HEDLEY_INTEL_VERSION)
233  #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
234 #else
235  #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0)
236 #endif
237 
238 #if defined(JSON_HEDLEY_PGI_VERSION)
239  #undef JSON_HEDLEY_PGI_VERSION
240 #endif
241 #if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__)
242  #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__)
243 #endif
244 
245 #if defined(JSON_HEDLEY_PGI_VERSION_CHECK)
246  #undef JSON_HEDLEY_PGI_VERSION_CHECK
247 #endif
248 #if defined(JSON_HEDLEY_PGI_VERSION)
249  #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
250 #else
251  #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0)
252 #endif
253 
254 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
255  #undef JSON_HEDLEY_SUNPRO_VERSION
256 #endif
257 #if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000)
258  #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10)
259 #elif defined(__SUNPRO_C)
260  #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf)
261 #elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000)
262  #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10)
263 #elif defined(__SUNPRO_CC)
264  #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf)
265 #endif
266 
267 #if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK)
268  #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
269 #endif
270 #if defined(JSON_HEDLEY_SUNPRO_VERSION)
271  #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
272 #else
273  #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0)
274 #endif
275 
276 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
277  #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
278 #endif
279 #if defined(__EMSCRIPTEN__)
280  #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__)
281 #endif
282 
283 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK)
284  #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
285 #endif
286 #if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION)
287  #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
288 #else
289  #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0)
290 #endif
291 
292 #if defined(JSON_HEDLEY_ARM_VERSION)
293  #undef JSON_HEDLEY_ARM_VERSION
294 #endif
295 #if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION)
296  #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100)
297 #elif defined(__CC_ARM) && defined(__ARMCC_VERSION)
298  #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100)
299 #endif
300 
301 #if defined(JSON_HEDLEY_ARM_VERSION_CHECK)
302  #undef JSON_HEDLEY_ARM_VERSION_CHECK
303 #endif
304 #if defined(JSON_HEDLEY_ARM_VERSION)
305  #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
306 #else
307  #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0)
308 #endif
309 
310 #if defined(JSON_HEDLEY_IBM_VERSION)
311  #undef JSON_HEDLEY_IBM_VERSION
312 #endif
313 #if defined(__ibmxl__)
314  #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__)
315 #elif defined(__xlC__) && defined(__xlC_ver__)
316  #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff)
317 #elif defined(__xlC__)
318  #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0)
319 #endif
320 
321 #if defined(JSON_HEDLEY_IBM_VERSION_CHECK)
322  #undef JSON_HEDLEY_IBM_VERSION_CHECK
323 #endif
324 #if defined(JSON_HEDLEY_IBM_VERSION)
325  #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
326 #else
327  #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0)
328 #endif
329 
330 #if defined(JSON_HEDLEY_TI_VERSION)
331  #undef JSON_HEDLEY_TI_VERSION
332 #endif
333 #if \
334  defined(__TI_COMPILER_VERSION__) && \
335  ( \
336  defined(__TMS470__) || defined(__TI_ARM__) || \
337  defined(__MSP430__) || \
338  defined(__TMS320C2000__) \
339  )
340 #if (__TI_COMPILER_VERSION__ >= 16000000)
341  #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
342 #endif
343 #endif
344 
345 #if defined(JSON_HEDLEY_TI_VERSION_CHECK)
346  #undef JSON_HEDLEY_TI_VERSION_CHECK
347 #endif
348 #if defined(JSON_HEDLEY_TI_VERSION)
349  #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
350 #else
351  #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0)
352 #endif
353 
354 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
355  #undef JSON_HEDLEY_TI_CL2000_VERSION
356 #endif
357 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__)
358  #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
359 #endif
360 
361 #if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK)
362  #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
363 #endif
364 #if defined(JSON_HEDLEY_TI_CL2000_VERSION)
365  #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
366 #else
367  #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0)
368 #endif
369 
370 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
371  #undef JSON_HEDLEY_TI_CL430_VERSION
372 #endif
373 #if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__)
374  #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
375 #endif
376 
377 #if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK)
378  #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
379 #endif
380 #if defined(JSON_HEDLEY_TI_CL430_VERSION)
381  #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
382 #else
383  #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0)
384 #endif
385 
386 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
387  #undef JSON_HEDLEY_TI_ARMCL_VERSION
388 #endif
389 #if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__))
390  #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
391 #endif
392 
393 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK)
394  #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
395 #endif
396 #if defined(JSON_HEDLEY_TI_ARMCL_VERSION)
397  #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
398 #else
399  #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0)
400 #endif
401 
402 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
403  #undef JSON_HEDLEY_TI_CL6X_VERSION
404 #endif
405 #if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__)
406  #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
407 #endif
408 
409 #if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK)
410  #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
411 #endif
412 #if defined(JSON_HEDLEY_TI_CL6X_VERSION)
413  #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
414 #else
415  #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0)
416 #endif
417 
418 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
419  #undef JSON_HEDLEY_TI_CL7X_VERSION
420 #endif
421 #if defined(__TI_COMPILER_VERSION__) && defined(__C7000__)
422  #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
423 #endif
424 
425 #if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK)
426  #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
427 #endif
428 #if defined(JSON_HEDLEY_TI_CL7X_VERSION)
429  #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
430 #else
431  #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0)
432 #endif
433 
434 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
435  #undef JSON_HEDLEY_TI_CLPRU_VERSION
436 #endif
437 #if defined(__TI_COMPILER_VERSION__) && defined(__PRU__)
438  #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000))
439 #endif
440 
441 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK)
442  #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
443 #endif
444 #if defined(JSON_HEDLEY_TI_CLPRU_VERSION)
445  #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
446 #else
447  #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0)
448 #endif
449 
450 #if defined(JSON_HEDLEY_CRAY_VERSION)
451  #undef JSON_HEDLEY_CRAY_VERSION
452 #endif
453 #if defined(_CRAYC)
454  #if defined(_RELEASE_PATCHLEVEL)
455  #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL)
456  #else
457  #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0)
458  #endif
459 #endif
460 
461 #if defined(JSON_HEDLEY_CRAY_VERSION_CHECK)
462  #undef JSON_HEDLEY_CRAY_VERSION_CHECK
463 #endif
464 #if defined(JSON_HEDLEY_CRAY_VERSION)
465  #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
466 #else
467  #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0)
468 #endif
469 
470 #if defined(JSON_HEDLEY_IAR_VERSION)
471  #undef JSON_HEDLEY_IAR_VERSION
472 #endif
473 #if defined(__IAR_SYSTEMS_ICC__)
474  #if __VER__ > 1000
475  #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000))
476  #else
477  #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(VER / 100, __VER__ % 100, 0)
478  #endif
479 #endif
480 
481 #if defined(JSON_HEDLEY_IAR_VERSION_CHECK)
482  #undef JSON_HEDLEY_IAR_VERSION_CHECK
483 #endif
484 #if defined(JSON_HEDLEY_IAR_VERSION)
485  #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
486 #else
487  #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0)
488 #endif
489 
490 #if defined(JSON_HEDLEY_TINYC_VERSION)
491  #undef JSON_HEDLEY_TINYC_VERSION
492 #endif
493 #if defined(__TINYC__)
494  #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100)
495 #endif
496 
497 #if defined(JSON_HEDLEY_TINYC_VERSION_CHECK)
498  #undef JSON_HEDLEY_TINYC_VERSION_CHECK
499 #endif
500 #if defined(JSON_HEDLEY_TINYC_VERSION)
501  #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
502 #else
503  #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0)
504 #endif
505 
506 #if defined(JSON_HEDLEY_DMC_VERSION)
507  #undef JSON_HEDLEY_DMC_VERSION
508 #endif
509 #if defined(__DMC__)
510  #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf)
511 #endif
512 
513 #if defined(JSON_HEDLEY_DMC_VERSION_CHECK)
514  #undef JSON_HEDLEY_DMC_VERSION_CHECK
515 #endif
516 #if defined(JSON_HEDLEY_DMC_VERSION)
517  #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
518 #else
519  #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0)
520 #endif
521 
522 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
523  #undef JSON_HEDLEY_COMPCERT_VERSION
524 #endif
525 #if defined(__COMPCERT_VERSION__)
526  #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100)
527 #endif
528 
529 #if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK)
530  #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
531 #endif
532 #if defined(JSON_HEDLEY_COMPCERT_VERSION)
533  #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
534 #else
535  #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0)
536 #endif
537 
538 #if defined(JSON_HEDLEY_PELLES_VERSION)
539  #undef JSON_HEDLEY_PELLES_VERSION
540 #endif
541 #if defined(__POCC__)
542  #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0)
543 #endif
544 
545 #if defined(JSON_HEDLEY_PELLES_VERSION_CHECK)
546  #undef JSON_HEDLEY_PELLES_VERSION_CHECK
547 #endif
548 #if defined(JSON_HEDLEY_PELLES_VERSION)
549  #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
550 #else
551  #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0)
552 #endif
553 
554 #if defined(JSON_HEDLEY_GCC_VERSION)
555  #undef JSON_HEDLEY_GCC_VERSION
556 #endif
557 #if \
558  defined(JSON_HEDLEY_GNUC_VERSION) && \
559  !defined(__clang__) && \
560  !defined(JSON_HEDLEY_INTEL_VERSION) && \
561  !defined(JSON_HEDLEY_PGI_VERSION) && \
562  !defined(JSON_HEDLEY_ARM_VERSION) && \
563  !defined(JSON_HEDLEY_TI_VERSION) && \
564  !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \
565  !defined(JSON_HEDLEY_TI_CL430_VERSION) && \
566  !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \
567  !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \
568  !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \
569  !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \
570  !defined(__COMPCERT__)
571  #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION
572 #endif
573 
574 #if defined(JSON_HEDLEY_GCC_VERSION_CHECK)
575  #undef JSON_HEDLEY_GCC_VERSION_CHECK
576 #endif
577 #if defined(JSON_HEDLEY_GCC_VERSION)
578  #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch))
579 #else
580  #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0)
581 #endif
582 
583 #if defined(JSON_HEDLEY_HAS_ATTRIBUTE)
584  #undef JSON_HEDLEY_HAS_ATTRIBUTE
585 #endif
586 #if defined(__has_attribute)
587  #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute)
588 #else
589  #define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0)
590 #endif
591 
592 #if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE)
593  #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
594 #endif
595 #if defined(__has_attribute)
596  #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
597 #else
598  #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
599 #endif
600 
601 #if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE)
602  #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
603 #endif
604 #if defined(__has_attribute)
605  #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) __has_attribute(attribute)
606 #else
607  #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
608 #endif
609 
610 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE)
611  #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
612 #endif
613 #if \
614  defined(__has_cpp_attribute) && \
615  defined(__cplusplus) && \
616  (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0))
617  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute)
618 #else
619  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0)
620 #endif
621 
622 #if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS)
623  #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
624 #endif
625 #if !defined(__cplusplus) || !defined(__has_cpp_attribute)
626  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
627 #elif \
628  !defined(JSON_HEDLEY_PGI_VERSION) && \
629  !defined(JSON_HEDLEY_IAR_VERSION) && \
630  (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \
631  (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0))
632  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute)
633 #else
634  #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0)
635 #endif
636 
637 #if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE)
638  #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
639 #endif
640 #if defined(__has_cpp_attribute) && defined(__cplusplus)
641  #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
642 #else
643  #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
644 #endif
645 
646 #if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE)
647  #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
648 #endif
649 #if defined(__has_cpp_attribute) && defined(__cplusplus)
650  #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute)
651 #else
652  #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
653 #endif
654 
655 #if defined(JSON_HEDLEY_HAS_BUILTIN)
656  #undef JSON_HEDLEY_HAS_BUILTIN
657 #endif
658 #if defined(__has_builtin)
659  #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin)
660 #else
661  #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0)
662 #endif
663 
664 #if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN)
665  #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
666 #endif
667 #if defined(__has_builtin)
668  #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
669 #else
670  #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
671 #endif
672 
673 #if defined(JSON_HEDLEY_GCC_HAS_BUILTIN)
674  #undef JSON_HEDLEY_GCC_HAS_BUILTIN
675 #endif
676 #if defined(__has_builtin)
677  #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin)
678 #else
679  #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
680 #endif
681 
682 #if defined(JSON_HEDLEY_HAS_FEATURE)
683  #undef JSON_HEDLEY_HAS_FEATURE
684 #endif
685 #if defined(__has_feature)
686  #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature)
687 #else
688  #define JSON_HEDLEY_HAS_FEATURE(feature) (0)
689 #endif
690 
691 #if defined(JSON_HEDLEY_GNUC_HAS_FEATURE)
692  #undef JSON_HEDLEY_GNUC_HAS_FEATURE
693 #endif
694 #if defined(__has_feature)
695  #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
696 #else
697  #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
698 #endif
699 
700 #if defined(JSON_HEDLEY_GCC_HAS_FEATURE)
701  #undef JSON_HEDLEY_GCC_HAS_FEATURE
702 #endif
703 #if defined(__has_feature)
704  #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature)
705 #else
706  #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
707 #endif
708 
709 #if defined(JSON_HEDLEY_HAS_EXTENSION)
710  #undef JSON_HEDLEY_HAS_EXTENSION
711 #endif
712 #if defined(__has_extension)
713  #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension)
714 #else
715  #define JSON_HEDLEY_HAS_EXTENSION(extension) (0)
716 #endif
717 
718 #if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION)
719  #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
720 #endif
721 #if defined(__has_extension)
722  #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
723 #else
724  #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
725 #endif
726 
727 #if defined(JSON_HEDLEY_GCC_HAS_EXTENSION)
728  #undef JSON_HEDLEY_GCC_HAS_EXTENSION
729 #endif
730 #if defined(__has_extension)
731  #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension)
732 #else
733  #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
734 #endif
735 
736 #if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE)
737  #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
738 #endif
739 #if defined(__has_declspec_attribute)
740  #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute)
741 #else
742  #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0)
743 #endif
744 
745 #if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE)
746  #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
747 #endif
748 #if defined(__has_declspec_attribute)
749  #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
750 #else
751  #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
752 #endif
753 
754 #if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE)
755  #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
756 #endif
757 #if defined(__has_declspec_attribute)
758  #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute)
759 #else
760  #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
761 #endif
762 
763 #if defined(JSON_HEDLEY_HAS_WARNING)
764  #undef JSON_HEDLEY_HAS_WARNING
765 #endif
766 #if defined(__has_warning)
767  #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning)
768 #else
769  #define JSON_HEDLEY_HAS_WARNING(warning) (0)
770 #endif
771 
772 #if defined(JSON_HEDLEY_GNUC_HAS_WARNING)
773  #undef JSON_HEDLEY_GNUC_HAS_WARNING
774 #endif
775 #if defined(__has_warning)
776  #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
777 #else
778  #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch)
779 #endif
780 
781 #if defined(JSON_HEDLEY_GCC_HAS_WARNING)
782  #undef JSON_HEDLEY_GCC_HAS_WARNING
783 #endif
784 #if defined(__has_warning)
785  #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning)
786 #else
787  #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
788 #endif
789 
790 /* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for
791  HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
792 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
793  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
794 #endif
795 #if defined(__cplusplus)
796 # if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat")
797 # if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions")
798 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
799  JSON_HEDLEY_DIAGNOSTIC_PUSH \
800  _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
801  _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \
802  xpr \
803  JSON_HEDLEY_DIAGNOSTIC_POP
804 # else
805 # define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \
806  JSON_HEDLEY_DIAGNOSTIC_PUSH \
807  _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \
808  xpr \
809  JSON_HEDLEY_DIAGNOSTIC_POP
810 # endif
811 # endif
812 #endif
813 #if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_)
814  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x
815 #endif
816 
817 #if defined(JSON_HEDLEY_CONST_CAST)
818  #undef JSON_HEDLEY_CONST_CAST
819 #endif
820 #if defined(__cplusplus)
821 # define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast<T>(expr))
822 #elif \
823  JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \
824  JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \
825  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
826 # define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \
827  JSON_HEDLEY_DIAGNOSTIC_PUSH \
828  JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \
829  ((T) (expr)); \
830  JSON_HEDLEY_DIAGNOSTIC_POP \
831  }))
832 #else
833 # define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr))
834 #endif
835 
836 #if defined(JSON_HEDLEY_REINTERPRET_CAST)
837  #undef JSON_HEDLEY_REINTERPRET_CAST
838 #endif
839 #if defined(__cplusplus)
840  #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast<T>(expr))
841 #else
842  #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr))
843 #endif
844 
845 #if defined(JSON_HEDLEY_STATIC_CAST)
846  #undef JSON_HEDLEY_STATIC_CAST
847 #endif
848 #if defined(__cplusplus)
849  #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast<T>(expr))
850 #else
851  #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr))
852 #endif
853 
854 #if defined(JSON_HEDLEY_CPP_CAST)
855  #undef JSON_HEDLEY_CPP_CAST
856 #endif
857 #if defined(__cplusplus)
858 # if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast")
859 # define JSON_HEDLEY_CPP_CAST(T, expr) \
860  JSON_HEDLEY_DIAGNOSTIC_PUSH \
861  _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \
862  ((T) (expr)) \
863  JSON_HEDLEY_DIAGNOSTIC_POP
864 # elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0)
865 # define JSON_HEDLEY_CPP_CAST(T, expr) \
866  JSON_HEDLEY_DIAGNOSTIC_PUSH \
867  _Pragma("diag_suppress=Pe137") \
868  JSON_HEDLEY_DIAGNOSTIC_POP \
869 # else
870 # define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr))
871 # endif
872 #else
873 # define JSON_HEDLEY_CPP_CAST(T, expr) (expr)
874 #endif
875 
876 #if \
877  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
878  defined(__clang__) || \
879  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
880  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
881  JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
882  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
883  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
884  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
885  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
886  JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
887  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
888  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \
889  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
890  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
891  JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \
892  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \
893  JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \
894  (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR))
895  #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value)
896 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
897  #define JSON_HEDLEY_PRAGMA(value) __pragma(value)
898 #else
899  #define JSON_HEDLEY_PRAGMA(value)
900 #endif
901 
902 #if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH)
903  #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
904 #endif
905 #if defined(JSON_HEDLEY_DIAGNOSTIC_POP)
906  #undef JSON_HEDLEY_DIAGNOSTIC_POP
907 #endif
908 #if defined(__clang__)
909  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push")
910  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop")
911 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
912  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
913  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
914 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
915  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push")
916  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop")
917 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
918  #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push))
919  #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop))
920 #elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0)
921  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push")
922  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop")
923 #elif \
924  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
925  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
926  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \
927  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
928  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
929  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
930  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push")
931  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop")
932 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
933  #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)")
934  #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)")
935 #else
936  #define JSON_HEDLEY_DIAGNOSTIC_PUSH
937  #define JSON_HEDLEY_DIAGNOSTIC_POP
938 #endif
939 
940 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED)
941  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
942 #endif
943 #if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations")
944  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
945 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
946  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)")
947 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
948  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444")
949 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
950  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
951 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
952  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996))
953 #elif \
954  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
955  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
956  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
957  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
958  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
959  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
960  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
961  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
962  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
963  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
964  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
965  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718")
966 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus)
967  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)")
968 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus)
969  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)")
970 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
971  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215")
972 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0)
973  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)")
974 #else
975  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
976 #endif
977 
978 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS)
979  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
980 #endif
981 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
982  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"")
983 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
984  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)")
985 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
986  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675")
987 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0)
988  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"")
989 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
990  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068))
991 #elif \
992  JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \
993  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
994  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
995  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
996  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
997 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0)
998  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163")
999 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1000  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161")
1001 #else
1002  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
1003 #endif
1004 
1005 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES)
1006  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1007 #endif
1008 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes")
1009  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"")
1010 #elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0)
1011  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
1012 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0)
1013  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)")
1014 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0)
1015  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030))
1016 #elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1017  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097")
1018 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)
1019  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)")
1020 #elif \
1021  JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1022  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1023  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0)
1024  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173")
1025 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1026  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097")
1027 #else
1028  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
1029 #endif
1030 
1031 #if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL)
1032  #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1033 #endif
1034 #if JSON_HEDLEY_HAS_WARNING("-Wcast-qual")
1035  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"")
1036 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1037  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)")
1038 #elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0)
1039  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"")
1040 #else
1041  #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
1042 #endif
1043 
1044 #if defined(JSON_HEDLEY_DEPRECATED)
1045  #undef JSON_HEDLEY_DEPRECATED
1046 #endif
1047 #if defined(JSON_HEDLEY_DEPRECATED_FOR)
1048  #undef JSON_HEDLEY_DEPRECATED_FOR
1049 #endif
1050 #if JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0)
1051  #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since))
1052  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement))
1053 #elif defined(__cplusplus) && (__cplusplus >= 201402L)
1054  #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]])
1055  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]])
1056 #elif \
1057  JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) || \
1058  JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1059  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1060  JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1061  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \
1062  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1063  JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \
1064  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \
1065  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \
1066  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1067  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0)
1068  #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since)))
1069  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement)))
1070 #elif \
1071  JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \
1072  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1073  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1074  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1075  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1076  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1077  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1078  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1079  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1080  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1081  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1082  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1083  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1084  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1085  #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__))
1086  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__))
1087 #elif \
1088  JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1089  JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0)
1090  #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated)
1091  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated)
1092 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1093  #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated")
1094  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated")
1095 #else
1096  #define JSON_HEDLEY_DEPRECATED(since)
1097  #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement)
1098 #endif
1099 
1100 #if defined(JSON_HEDLEY_UNAVAILABLE)
1101  #undef JSON_HEDLEY_UNAVAILABLE
1102 #endif
1103 #if \
1104  JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \
1105  JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \
1106  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1107  #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since)))
1108 #else
1109  #define JSON_HEDLEY_UNAVAILABLE(available_since)
1110 #endif
1111 
1112 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT)
1113  #undef JSON_HEDLEY_WARN_UNUSED_RESULT
1114 #endif
1115 #if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG)
1116  #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
1117 #endif
1118 #if (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L)
1119  #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1120  #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]])
1121 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard)
1122  #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1123  #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]])
1124 #elif \
1125  JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \
1126  JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1127  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1128  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1129  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1130  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1131  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1132  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1133  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1134  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1135  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1136  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1137  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1138  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1139  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1140  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1141  #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__))
1142  #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__))
1143 #elif defined(_Check_return_) /* SAL */
1144  #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_
1145  #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_
1146 #else
1147  #define JSON_HEDLEY_WARN_UNUSED_RESULT
1148  #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg)
1149 #endif
1150 
1151 #if defined(JSON_HEDLEY_SENTINEL)
1152  #undef JSON_HEDLEY_SENTINEL
1153 #endif
1154 #if \
1155  JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \
1156  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1157  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1158  JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0)
1159  #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position)))
1160 #else
1161  #define JSON_HEDLEY_SENTINEL(position)
1162 #endif
1163 
1164 #if defined(JSON_HEDLEY_NO_RETURN)
1165  #undef JSON_HEDLEY_NO_RETURN
1166 #endif
1167 #if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1168  #define JSON_HEDLEY_NO_RETURN __noreturn
1169 #elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1170  #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1171 #elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L
1172  #define JSON_HEDLEY_NO_RETURN _Noreturn
1173 #elif defined(__cplusplus) && (__cplusplus >= 201103L)
1174  #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]])
1175 #elif \
1176  JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \
1177  JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \
1178  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1179  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1180  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1181  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1182  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1183  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1184  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1185  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1186  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1187  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1188  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1189  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1190  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1191  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1192  #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__))
1193 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1194  #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return")
1195 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
1196  #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1197 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1198  #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;")
1199 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1200  #define JSON_HEDLEY_NO_RETURN __attribute((noreturn))
1201 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1202  #define JSON_HEDLEY_NO_RETURN __declspec(noreturn)
1203 #else
1204  #define JSON_HEDLEY_NO_RETURN
1205 #endif
1206 
1207 #if defined(JSON_HEDLEY_NO_ESCAPE)
1208  #undef JSON_HEDLEY_NO_ESCAPE
1209 #endif
1210 #if JSON_HEDLEY_HAS_ATTRIBUTE(noescape)
1211  #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__))
1212 #else
1213  #define JSON_HEDLEY_NO_ESCAPE
1214 #endif
1215 
1216 #if defined(JSON_HEDLEY_UNREACHABLE)
1217  #undef JSON_HEDLEY_UNREACHABLE
1218 #endif
1219 #if defined(JSON_HEDLEY_UNREACHABLE_RETURN)
1220  #undef JSON_HEDLEY_UNREACHABLE_RETURN
1221 #endif
1222 #if defined(JSON_HEDLEY_ASSUME)
1223  #undef JSON_HEDLEY_ASSUME
1224 #endif
1225 #if \
1226  JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \
1227  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1228  #define JSON_HEDLEY_ASSUME(expr) __assume(expr)
1229 #elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume)
1230  #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr)
1231 #elif \
1232  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1233  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1234  #if defined(__cplusplus)
1235  #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr)
1236  #else
1237  #define JSON_HEDLEY_ASSUME(expr) _nassert(expr)
1238  #endif
1239 #endif
1240 #if \
1241  (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \
1242  JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \
1243  JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \
1244  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1245  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5)
1246  #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable()
1247 #elif defined(JSON_HEDLEY_ASSUME)
1248  #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1249 #endif
1250 #if !defined(JSON_HEDLEY_ASSUME)
1251  #if defined(JSON_HEDLEY_UNREACHABLE)
1252  #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1)))
1253  #else
1254  #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr)
1255  #endif
1256 #endif
1257 #if defined(JSON_HEDLEY_UNREACHABLE)
1258  #if \
1259  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1260  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0)
1261  #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value))
1262  #else
1263  #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE()
1264  #endif
1265 #else
1266  #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value)
1267 #endif
1268 #if !defined(JSON_HEDLEY_UNREACHABLE)
1269  #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0)
1270 #endif
1271 
1272 JSON_HEDLEY_DIAGNOSTIC_PUSH
1273 #if JSON_HEDLEY_HAS_WARNING("-Wpedantic")
1274  #pragma clang diagnostic ignored "-Wpedantic"
1275 #endif
1276 #if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus)
1277  #pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
1278 #endif
1279 #if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0)
1280  #if defined(__clang__)
1281  #pragma clang diagnostic ignored "-Wvariadic-macros"
1282  #elif defined(JSON_HEDLEY_GCC_VERSION)
1283  #pragma GCC diagnostic ignored "-Wvariadic-macros"
1284  #endif
1285 #endif
1286 #if defined(JSON_HEDLEY_NON_NULL)
1287  #undef JSON_HEDLEY_NON_NULL
1288 #endif
1289 #if \
1290  JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \
1291  JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1292  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1293  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1294  #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__)))
1295 #else
1296  #define JSON_HEDLEY_NON_NULL(...)
1297 #endif
1298 JSON_HEDLEY_DIAGNOSTIC_POP
1299 
1300 #if defined(JSON_HEDLEY_PRINTF_FORMAT)
1301  #undef JSON_HEDLEY_PRINTF_FORMAT
1302 #endif
1303 #if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO)
1304  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check)))
1305 #elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO)
1306  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check)))
1307 #elif \
1308  JSON_HEDLEY_HAS_ATTRIBUTE(format) || \
1309  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1310  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1311  JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \
1312  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1313  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1314  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1315  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1316  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1317  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1318  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1319  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1320  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1321  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1322  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1323  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1324  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check)))
1325 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0)
1326  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check))
1327 #else
1328  #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check)
1329 #endif
1330 
1331 #if defined(JSON_HEDLEY_CONSTEXPR)
1332  #undef JSON_HEDLEY_CONSTEXPR
1333 #endif
1334 #if defined(__cplusplus)
1335  #if __cplusplus >= 201103L
1336  #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr)
1337  #endif
1338 #endif
1339 #if !defined(JSON_HEDLEY_CONSTEXPR)
1340  #define JSON_HEDLEY_CONSTEXPR
1341 #endif
1342 
1343 #if defined(JSON_HEDLEY_PREDICT)
1344  #undef JSON_HEDLEY_PREDICT
1345 #endif
1346 #if defined(JSON_HEDLEY_LIKELY)
1347  #undef JSON_HEDLEY_LIKELY
1348 #endif
1349 #if defined(JSON_HEDLEY_UNLIKELY)
1350  #undef JSON_HEDLEY_UNLIKELY
1351 #endif
1352 #if defined(JSON_HEDLEY_UNPREDICTABLE)
1353  #undef JSON_HEDLEY_UNPREDICTABLE
1354 #endif
1355 #if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable)
1356  #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr))
1357 #endif
1358 #if \
1359  JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) || \
1360  JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0)
1361 # define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability))
1362 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability))
1363 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability))
1364 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 )
1365 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 )
1366 #elif \
1367  JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) || \
1368  JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \
1369  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1370  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \
1371  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1372  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1373  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1374  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \
1375  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1376  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \
1377  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1378  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1379  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1380  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \
1381  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
1382 # define JSON_HEDLEY_PREDICT(expr, expected, probability) \
1383  (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)))
1384 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \
1385  (__extension__ ({ \
1386  double hedley_probability_ = (probability); \
1387  ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \
1388  }))
1389 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \
1390  (__extension__ ({ \
1391  double hedley_probability_ = (probability); \
1392  ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \
1393  }))
1394 # define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1)
1395 # define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0)
1396 #else
1397 # define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))
1398 # define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr))
1399 # define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr))
1400 # define JSON_HEDLEY_LIKELY(expr) (!!(expr))
1401 # define JSON_HEDLEY_UNLIKELY(expr) (!!(expr))
1402 #endif
1403 #if !defined(JSON_HEDLEY_UNPREDICTABLE)
1404  #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5)
1405 #endif
1406 
1407 #if defined(JSON_HEDLEY_MALLOC)
1408  #undef JSON_HEDLEY_MALLOC
1409 #endif
1410 #if \
1411  JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \
1412  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1413  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1414  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1415  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1416  JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1417  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1418  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1419  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1420  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1421  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1422  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1423  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1424  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1425  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1426  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1427  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1428  #define JSON_HEDLEY_MALLOC __attribute__((__malloc__))
1429 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1430  #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory")
1431 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(14, 0, 0)
1432  #define JSON_HEDLEY_MALLOC __declspec(restrict)
1433 #else
1434  #define JSON_HEDLEY_MALLOC
1435 #endif
1436 
1437 #if defined(JSON_HEDLEY_PURE)
1438  #undef JSON_HEDLEY_PURE
1439 #endif
1440 #if \
1441  JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \
1442  JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \
1443  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1444  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1445  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1446  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1447  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1448  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1449  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1450  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1451  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1452  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1453  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1454  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1455  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1456  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1457  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1458  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1459 # define JSON_HEDLEY_PURE __attribute__((__pure__))
1460 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1461 # define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data")
1462 #elif defined(__cplusplus) && \
1463  ( \
1464  JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \
1465  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \
1466  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \
1467  )
1468 # define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;")
1469 #else
1470 # define JSON_HEDLEY_PURE
1471 #endif
1472 
1473 #if defined(JSON_HEDLEY_CONST)
1474  #undef JSON_HEDLEY_CONST
1475 #endif
1476 #if \
1477  JSON_HEDLEY_HAS_ATTRIBUTE(const) || \
1478  JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \
1479  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1480  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1481  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1482  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1483  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1484  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1485  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1486  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1487  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1488  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1489  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1490  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1491  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1492  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1493  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \
1494  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0)
1495  #define JSON_HEDLEY_CONST __attribute__((__const__))
1496 #elif \
1497  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0)
1498  #define JSON_HEDLEY_CONST _Pragma("no_side_effect")
1499 #else
1500  #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE
1501 #endif
1502 
1503 #if defined(JSON_HEDLEY_RESTRICT)
1504  #undef JSON_HEDLEY_RESTRICT
1505 #endif
1506 #if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus)
1507  #define JSON_HEDLEY_RESTRICT restrict
1508 #elif \
1509  JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \
1510  JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \
1511  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1512  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1513  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1514  JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \
1515  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1516  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \
1517  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \
1518  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1519  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \
1520  JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \
1521  defined(__clang__)
1522  #define JSON_HEDLEY_RESTRICT __restrict
1523 #elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus)
1524  #define JSON_HEDLEY_RESTRICT _Restrict
1525 #else
1526  #define JSON_HEDLEY_RESTRICT
1527 #endif
1528 
1529 #if defined(JSON_HEDLEY_INLINE)
1530  #undef JSON_HEDLEY_INLINE
1531 #endif
1532 #if \
1533  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \
1534  (defined(__cplusplus) && (__cplusplus >= 199711L))
1535  #define JSON_HEDLEY_INLINE inline
1536 #elif \
1537  defined(JSON_HEDLEY_GCC_VERSION) || \
1538  JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0)
1539  #define JSON_HEDLEY_INLINE __inline__
1540 #elif \
1541  JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \
1542  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1543  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \
1544  JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \
1545  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \
1546  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \
1547  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1548  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1549  #define JSON_HEDLEY_INLINE __inline
1550 #else
1551  #define JSON_HEDLEY_INLINE
1552 #endif
1553 
1554 #if defined(JSON_HEDLEY_ALWAYS_INLINE)
1555  #undef JSON_HEDLEY_ALWAYS_INLINE
1556 #endif
1557 #if \
1558  JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \
1559  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1560  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1561  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1562  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1563  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1564  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1565  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1566  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1567  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1568  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1569  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1570  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1571  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1572  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1573  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1574  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1575 # define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE
1576 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0)
1577 # define JSON_HEDLEY_ALWAYS_INLINE __forceinline
1578 #elif defined(__cplusplus) && \
1579  ( \
1580  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1581  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1582  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1583  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1584  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1585  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \
1586  )
1587 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;")
1588 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1589 # define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced")
1590 #else
1591 # define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE
1592 #endif
1593 
1594 #if defined(JSON_HEDLEY_NEVER_INLINE)
1595  #undef JSON_HEDLEY_NEVER_INLINE
1596 #endif
1597 #if \
1598  JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \
1599  JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \
1600  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1601  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1602  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1603  JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
1604  JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \
1605  (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1606  JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \
1607  (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1608  JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \
1609  (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1610  JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \
1611  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1612  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \
1613  JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \
1614  JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0)
1615  #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__))
1616 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0)
1617  #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1618 #elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0)
1619  #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline")
1620 #elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus)
1621  #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
1622 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1623  #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never")
1624 #elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0)
1625  #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline))
1626 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0)
1627  #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline)
1628 #else
1629  #define JSON_HEDLEY_NEVER_INLINE
1630 #endif
1631 
1632 #if defined(JSON_HEDLEY_PRIVATE)
1633  #undef JSON_HEDLEY_PRIVATE
1634 #endif
1635 #if defined(JSON_HEDLEY_PUBLIC)
1636  #undef JSON_HEDLEY_PUBLIC
1637 #endif
1638 #if defined(JSON_HEDLEY_IMPORT)
1639  #undef JSON_HEDLEY_IMPORT
1640 #endif
1641 #if defined(_WIN32) || defined(__CYGWIN__)
1642 # define JSON_HEDLEY_PRIVATE
1643 # define JSON_HEDLEY_PUBLIC __declspec(dllexport)
1644 # define JSON_HEDLEY_IMPORT __declspec(dllimport)
1645 #else
1646 # if \
1647  JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \
1648  JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1649  JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
1650  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1651  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1652  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1653  ( \
1654  defined(__TI_EABI__) && \
1655  ( \
1656  (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \
1657  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \
1658  ) \
1659  )
1660 # define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden")))
1661 # define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default")))
1662 # else
1663 # define JSON_HEDLEY_PRIVATE
1664 # define JSON_HEDLEY_PUBLIC
1665 # endif
1666 # define JSON_HEDLEY_IMPORT extern
1667 #endif
1668 
1669 #if defined(JSON_HEDLEY_NO_THROW)
1670  #undef JSON_HEDLEY_NO_THROW
1671 #endif
1672 #if \
1673  JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \
1674  JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \
1675  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1676  #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__))
1677 #elif \
1678  JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \
1679  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0)
1680  #define JSON_HEDLEY_NO_THROW __declspec(nothrow)
1681 #else
1682  #define JSON_HEDLEY_NO_THROW
1683 #endif
1684 
1685 #if defined(JSON_HEDLEY_FALL_THROUGH)
1686  #undef JSON_HEDLEY_FALL_THROUGH
1687 #endif
1688 #if \
1689  JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \
1690  JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0)
1691  #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__))
1692 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough)
1693  #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]])
1694 #elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough)
1695  #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]])
1696 #elif defined(__fallthrough) /* SAL */
1697  #define JSON_HEDLEY_FALL_THROUGH __fallthrough
1698 #else
1699  #define JSON_HEDLEY_FALL_THROUGH
1700 #endif
1701 
1702 #if defined(JSON_HEDLEY_RETURNS_NON_NULL)
1703  #undef JSON_HEDLEY_RETURNS_NON_NULL
1704 #endif
1705 #if \
1706  JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \
1707  JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0)
1708  #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__))
1709 #elif defined(_Ret_notnull_) /* SAL */
1710  #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_
1711 #else
1712  #define JSON_HEDLEY_RETURNS_NON_NULL
1713 #endif
1714 
1715 #if defined(JSON_HEDLEY_ARRAY_PARAM)
1716  #undef JSON_HEDLEY_ARRAY_PARAM
1717 #endif
1718 #if \
1719  defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \
1720  !defined(__STDC_NO_VLA__) && \
1721  !defined(__cplusplus) && \
1722  !defined(JSON_HEDLEY_PGI_VERSION) && \
1723  !defined(JSON_HEDLEY_TINYC_VERSION)
1724  #define JSON_HEDLEY_ARRAY_PARAM(name) (name)
1725 #else
1726  #define JSON_HEDLEY_ARRAY_PARAM(name)
1727 #endif
1728 
1729 #if defined(JSON_HEDLEY_IS_CONSTANT)
1730  #undef JSON_HEDLEY_IS_CONSTANT
1731 #endif
1732 #if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR)
1733  #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
1734 #endif
1735 /* JSON_HEDLEY_IS_CONSTEXPR_ is for
1736  HEDLEY INTERNAL USE ONLY. API subject to change without notice. */
1737 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1738  #undef JSON_HEDLEY_IS_CONSTEXPR_
1739 #endif
1740 #if \
1741  JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \
1742  JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1743  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1744  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \
1745  JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
1746  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1747  JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \
1748  (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \
1749  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0)
1750  #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr)
1751 #endif
1752 #if !defined(__cplusplus)
1753 # if \
1754  JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \
1755  JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \
1756  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1757  JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \
1758  JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \
1759  JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \
1760  JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24)
1761 #if defined(__INTPTR_TYPE__)
1762  #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*)
1763 #else
1764  #include <stdint.h>
1765  #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*)
1766 #endif
1767 # elif \
1768  ( \
1769  defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \
1770  !defined(JSON_HEDLEY_SUNPRO_VERSION) && \
1771  !defined(JSON_HEDLEY_PGI_VERSION) && \
1772  !defined(JSON_HEDLEY_IAR_VERSION)) || \
1773  JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) || \
1774  JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \
1775  JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \
1776  JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \
1777  JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0)
1778 #if defined(__INTPTR_TYPE__)
1779  #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0)
1780 #else
1781  #include <stdint.h>
1782  #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0)
1783 #endif
1784 # elif \
1785  defined(JSON_HEDLEY_GCC_VERSION) || \
1786  defined(JSON_HEDLEY_INTEL_VERSION) || \
1787  defined(JSON_HEDLEY_TINYC_VERSION) || \
1788  defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \
1789  JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \
1790  defined(JSON_HEDLEY_TI_CL2000_VERSION) || \
1791  defined(JSON_HEDLEY_TI_CL6X_VERSION) || \
1792  defined(JSON_HEDLEY_TI_CL7X_VERSION) || \
1793  defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \
1794  defined(__clang__)
1795 # define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \
1796  sizeof(void) != \
1797  sizeof(*( \
1798  1 ? \
1799  ((void*) ((expr) * 0L) ) : \
1800 ((struct { char v[sizeof(void) * 2]; } *) 1) \
1801  ) \
1802  ) \
1803  )
1804 # endif
1805 #endif
1806 #if defined(JSON_HEDLEY_IS_CONSTEXPR_)
1807  #if !defined(JSON_HEDLEY_IS_CONSTANT)
1808  #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr)
1809  #endif
1810  #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1))
1811 #else
1812  #if !defined(JSON_HEDLEY_IS_CONSTANT)
1813  #define JSON_HEDLEY_IS_CONSTANT(expr) (0)
1814  #endif
1815  #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr)
1816 #endif
1817 
1818 #if defined(JSON_HEDLEY_BEGIN_C_DECLS)
1819  #undef JSON_HEDLEY_BEGIN_C_DECLS
1820 #endif
1821 #if defined(JSON_HEDLEY_END_C_DECLS)
1822  #undef JSON_HEDLEY_END_C_DECLS
1823 #endif
1824 #if defined(JSON_HEDLEY_C_DECL)
1825  #undef JSON_HEDLEY_C_DECL
1826 #endif
1827 #if defined(__cplusplus)
1828  #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" {
1829  #define JSON_HEDLEY_END_C_DECLS }
1830  #define JSON_HEDLEY_C_DECL extern "C"
1831 #else
1832  #define JSON_HEDLEY_BEGIN_C_DECLS
1833  #define JSON_HEDLEY_END_C_DECLS
1834  #define JSON_HEDLEY_C_DECL
1835 #endif
1836 
1837 #if defined(JSON_HEDLEY_STATIC_ASSERT)
1838  #undef JSON_HEDLEY_STATIC_ASSERT
1839 #endif
1840 #if \
1841  !defined(__cplusplus) && ( \
1842  (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \
1843  JSON_HEDLEY_HAS_FEATURE(c_static_assert) || \
1844  JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \
1845  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \
1846  defined(_Static_assert) \
1847  )
1848 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message)
1849 #elif \
1850  (defined(__cplusplus) && (__cplusplus >= 201103L)) || \
1851  JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0)
1852 # define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message))
1853 #else
1854 # define JSON_HEDLEY_STATIC_ASSERT(expr, message)
1855 #endif
1856 
1857 #if defined(JSON_HEDLEY_NULL)
1858  #undef JSON_HEDLEY_NULL
1859 #endif
1860 #if defined(__cplusplus)
1861  #if __cplusplus >= 201103L
1862  #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr)
1863  #elif defined(NULL)
1864  #define JSON_HEDLEY_NULL NULL
1865  #else
1866  #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0)
1867  #endif
1868 #elif defined(NULL)
1869  #define JSON_HEDLEY_NULL NULL
1870 #else
1871  #define JSON_HEDLEY_NULL ((void*) 0)
1872 #endif
1873 
1874 #if defined(JSON_HEDLEY_MESSAGE)
1875  #undef JSON_HEDLEY_MESSAGE
1876 #endif
1877 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1878 # define JSON_HEDLEY_MESSAGE(msg) \
1879  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1880  JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1881  JSON_HEDLEY_PRAGMA(message msg) \
1882  JSON_HEDLEY_DIAGNOSTIC_POP
1883 #elif \
1884  JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \
1885  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1886 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg)
1887 #elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0)
1888 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg)
1889 #elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0)
1890 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1891 #elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0)
1892 # define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg))
1893 #else
1894 # define JSON_HEDLEY_MESSAGE(msg)
1895 #endif
1896 
1897 #if defined(JSON_HEDLEY_WARNING)
1898  #undef JSON_HEDLEY_WARNING
1899 #endif
1900 #if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas")
1901 # define JSON_HEDLEY_WARNING(msg) \
1902  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1903  JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \
1904  JSON_HEDLEY_PRAGMA(clang warning msg) \
1905  JSON_HEDLEY_DIAGNOSTIC_POP
1906 #elif \
1907  JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \
1908  JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \
1909  JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0)
1910 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg)
1911 #elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0)
1912 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg))
1913 #else
1914 # define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg)
1915 #endif
1916 
1917 #if defined(JSON_HEDLEY_REQUIRE)
1918  #undef JSON_HEDLEY_REQUIRE
1919 #endif
1920 #if defined(JSON_HEDLEY_REQUIRE_MSG)
1921  #undef JSON_HEDLEY_REQUIRE_MSG
1922 #endif
1923 #if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if)
1924 # if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat")
1925 # define JSON_HEDLEY_REQUIRE(expr) \
1926  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1927  _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1928  __attribute__((diagnose_if(!(expr), #expr, "error"))) \
1929  JSON_HEDLEY_DIAGNOSTIC_POP
1930 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \
1931  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1932  _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \
1933  __attribute__((diagnose_if(!(expr), msg, "error"))) \
1934  JSON_HEDLEY_DIAGNOSTIC_POP
1935 # else
1936 # define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error")))
1937 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error")))
1938 # endif
1939 #else
1940 # define JSON_HEDLEY_REQUIRE(expr)
1941 # define JSON_HEDLEY_REQUIRE_MSG(expr,msg)
1942 #endif
1943 
1944 #if defined(JSON_HEDLEY_FLAGS)
1945  #undef JSON_HEDLEY_FLAGS
1946 #endif
1947 #if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum)
1948  #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__))
1949 #endif
1950 
1951 #if defined(JSON_HEDLEY_FLAGS_CAST)
1952  #undef JSON_HEDLEY_FLAGS_CAST
1953 #endif
1954 #if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0)
1955 # define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \
1956  JSON_HEDLEY_DIAGNOSTIC_PUSH \
1957  _Pragma("warning(disable:188)") \
1958  ((T) (expr)); \
1959  JSON_HEDLEY_DIAGNOSTIC_POP \
1960  }))
1961 #else
1962 # define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr)
1963 #endif
1964 
1965 #if defined(JSON_HEDLEY_EMPTY_BASES)
1966  #undef JSON_HEDLEY_EMPTY_BASES
1967 #endif
1968 #if JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)
1969  #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases)
1970 #else
1971  #define JSON_HEDLEY_EMPTY_BASES
1972 #endif
1973 
1974 /* Remaining macros are deprecated. */
1975 
1976 #if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK)
1977  #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
1978 #endif
1979 #if defined(__clang__)
1980  #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0)
1981 #else
1982  #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch)
1983 #endif
1984 
1985 #if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE)
1986  #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
1987 #endif
1988 #define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute)
1989 
1990 #if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE)
1991  #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
1992 #endif
1993 #define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute)
1994 
1995 #if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN)
1996  #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
1997 #endif
1998 #define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin)
1999 
2000 #if defined(JSON_HEDLEY_CLANG_HAS_FEATURE)
2001  #undef JSON_HEDLEY_CLANG_HAS_FEATURE
2002 #endif
2003 #define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature)
2004 
2005 #if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION)
2006  #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
2007 #endif
2008 #define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension)
2009 
2010 #if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE)
2011  #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
2012 #endif
2013 #define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute)
2014 
2015 #if defined(JSON_HEDLEY_CLANG_HAS_WARNING)
2016  #undef JSON_HEDLEY_CLANG_HAS_WARNING
2017 #endif
2018 #define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning)
2019 
2020 #endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */
2021 
2022 
2023 // This file contains all internal macro definitions
2024 // You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them
2025 
2026 // exclude unsupported compilers
2027 #if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK)
2028  #if defined(__clang__)
2029  #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400
2030  #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers"
2031  #endif
2032  #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER))
2033  #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800
2034  #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers"
2035  #endif
2036  #endif
2037 #endif
2038 
2039 // C++ language standard detection
2040 #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
2041  #define JSON_HAS_CPP_20
2042  #define JSON_HAS_CPP_17
2043  #define JSON_HAS_CPP_14
2044 #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
2045  #define JSON_HAS_CPP_17
2046  #define JSON_HAS_CPP_14
2047 #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
2048  #define JSON_HAS_CPP_14
2049 #endif
2050 
2051 // disable float-equal warnings on GCC/clang
2052 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
2053  #pragma GCC diagnostic push
2054  #pragma GCC diagnostic ignored "-Wfloat-equal"
2055 #endif
2056 
2057 // disable documentation warnings on clang
2058 #if defined(__clang__)
2059  #pragma GCC diagnostic push
2060  #pragma GCC diagnostic ignored "-Wdocumentation"
2061 #endif
2062 
2063 // allow to disable exceptions
2064 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
2065  #define JSON_THROW(exception) throw exception
2066  #define JSON_TRY try
2067  #define JSON_CATCH(exception) catch(exception)
2068  #define JSON_INTERNAL_CATCH(exception) catch(exception)
2069 #else
2070  #include <cstdlib>
2071  #define JSON_THROW(exception) std::abort()
2072  #define JSON_TRY if(true)
2073  #define JSON_CATCH(exception) if(false)
2074  #define JSON_INTERNAL_CATCH(exception) if(false)
2075 #endif
2076 
2077 // override exception macros
2078 #if defined(JSON_THROW_USER)
2079  #undef JSON_THROW
2080  #define JSON_THROW JSON_THROW_USER
2081 #endif
2082 #if defined(JSON_TRY_USER)
2083  #undef JSON_TRY
2084  #define JSON_TRY JSON_TRY_USER
2085 #endif
2086 #if defined(JSON_CATCH_USER)
2087  #undef JSON_CATCH
2088  #define JSON_CATCH JSON_CATCH_USER
2089  #undef JSON_INTERNAL_CATCH
2090  #define JSON_INTERNAL_CATCH JSON_CATCH_USER
2091 #endif
2092 #if defined(JSON_INTERNAL_CATCH_USER)
2093  #undef JSON_INTERNAL_CATCH
2094  #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER
2095 #endif
2096 
2097 // allow to override assert
2098 #if !defined(JSON_ASSERT)
2099  #include <cassert> // assert
2100  #define JSON_ASSERT(x) assert(x)
2101 #endif
2102 
2103 /*!
2104 @brief macro to briefly define a mapping between an enum and JSON
2105 @def NLOHMANN_JSON_SERIALIZE_ENUM
2106 @since version 3.4.0
2107 */
2108 #define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \
2109  template<typename BasicJsonType> \
2110  inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \
2111  { \
2112  static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2113  static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2114  auto it = std::find_if(std::begin(m), std::end(m), \
2115  [e](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2116  { \
2117  return ej_pair.first == e; \
2118  }); \
2119  j = ((it != std::end(m)) ? it : std::begin(m))->second; \
2120  } \
2121  template<typename BasicJsonType> \
2122  inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \
2123  { \
2124  static_assert(std::is_enum<ENUM_TYPE>::value, #ENUM_TYPE " must be an enum!"); \
2125  static const std::pair<ENUM_TYPE, BasicJsonType> m[] = __VA_ARGS__; \
2126  auto it = std::find_if(std::begin(m), std::end(m), \
2127  [&j](const std::pair<ENUM_TYPE, BasicJsonType>& ej_pair) -> bool \
2128  { \
2129  return ej_pair.second == j; \
2130  }); \
2131  e = ((it != std::end(m)) ? it : std::begin(m))->first; \
2132  }
2133 
2134 // Ugly macros to avoid uglier copy-paste when specializing basic_json. They
2135 // may be removed in the future once the class is split.
2136 
2137 #define NLOHMANN_BASIC_JSON_TPL_DECLARATION \
2138  template<template<typename, typename, typename...> class ObjectType, \
2139  template<typename, typename...> class ArrayType, \
2140  class StringType, class BooleanType, class NumberIntegerType, \
2141  class NumberUnsignedType, class NumberFloatType, \
2142  template<typename> class AllocatorType, \
2143  template<typename, typename = void> class JSONSerializer, \
2144  class BinaryType>
2145 
2146 #define NLOHMANN_BASIC_JSON_TPL \
2147  basic_json<ObjectType, ArrayType, StringType, BooleanType, \
2148  NumberIntegerType, NumberUnsignedType, NumberFloatType, \
2149  AllocatorType, JSONSerializer, BinaryType>
2150 
2151 // Macros to simplify conversion from/to types
2152 
2153 #define NLOHMANN_JSON_EXPAND( x ) x
2154 #define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME
2155 #define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \
2156  NLOHMANN_JSON_PASTE64, \
2157  NLOHMANN_JSON_PASTE63, \
2158  NLOHMANN_JSON_PASTE62, \
2159  NLOHMANN_JSON_PASTE61, \
2160  NLOHMANN_JSON_PASTE60, \
2161  NLOHMANN_JSON_PASTE59, \
2162  NLOHMANN_JSON_PASTE58, \
2163  NLOHMANN_JSON_PASTE57, \
2164  NLOHMANN_JSON_PASTE56, \
2165  NLOHMANN_JSON_PASTE55, \
2166  NLOHMANN_JSON_PASTE54, \
2167  NLOHMANN_JSON_PASTE53, \
2168  NLOHMANN_JSON_PASTE52, \
2169  NLOHMANN_JSON_PASTE51, \
2170  NLOHMANN_JSON_PASTE50, \
2171  NLOHMANN_JSON_PASTE49, \
2172  NLOHMANN_JSON_PASTE48, \
2173  NLOHMANN_JSON_PASTE47, \
2174  NLOHMANN_JSON_PASTE46, \
2175  NLOHMANN_JSON_PASTE45, \
2176  NLOHMANN_JSON_PASTE44, \
2177  NLOHMANN_JSON_PASTE43, \
2178  NLOHMANN_JSON_PASTE42, \
2179  NLOHMANN_JSON_PASTE41, \
2180  NLOHMANN_JSON_PASTE40, \
2181  NLOHMANN_JSON_PASTE39, \
2182  NLOHMANN_JSON_PASTE38, \
2183  NLOHMANN_JSON_PASTE37, \
2184  NLOHMANN_JSON_PASTE36, \
2185  NLOHMANN_JSON_PASTE35, \
2186  NLOHMANN_JSON_PASTE34, \
2187  NLOHMANN_JSON_PASTE33, \
2188  NLOHMANN_JSON_PASTE32, \
2189  NLOHMANN_JSON_PASTE31, \
2190  NLOHMANN_JSON_PASTE30, \
2191  NLOHMANN_JSON_PASTE29, \
2192  NLOHMANN_JSON_PASTE28, \
2193  NLOHMANN_JSON_PASTE27, \
2194  NLOHMANN_JSON_PASTE26, \
2195  NLOHMANN_JSON_PASTE25, \
2196  NLOHMANN_JSON_PASTE24, \
2197  NLOHMANN_JSON_PASTE23, \
2198  NLOHMANN_JSON_PASTE22, \
2199  NLOHMANN_JSON_PASTE21, \
2200  NLOHMANN_JSON_PASTE20, \
2201  NLOHMANN_JSON_PASTE19, \
2202  NLOHMANN_JSON_PASTE18, \
2203  NLOHMANN_JSON_PASTE17, \
2204  NLOHMANN_JSON_PASTE16, \
2205  NLOHMANN_JSON_PASTE15, \
2206  NLOHMANN_JSON_PASTE14, \
2207  NLOHMANN_JSON_PASTE13, \
2208  NLOHMANN_JSON_PASTE12, \
2209  NLOHMANN_JSON_PASTE11, \
2210  NLOHMANN_JSON_PASTE10, \
2211  NLOHMANN_JSON_PASTE9, \
2212  NLOHMANN_JSON_PASTE8, \
2213  NLOHMANN_JSON_PASTE7, \
2214  NLOHMANN_JSON_PASTE6, \
2215  NLOHMANN_JSON_PASTE5, \
2216  NLOHMANN_JSON_PASTE4, \
2217  NLOHMANN_JSON_PASTE3, \
2218  NLOHMANN_JSON_PASTE2, \
2219  NLOHMANN_JSON_PASTE1)(__VA_ARGS__))
2220 #define NLOHMANN_JSON_PASTE2(func, v1) func(v1)
2221 #define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2)
2222 #define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3)
2223 #define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4)
2224 #define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5)
2225 #define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6)
2226 #define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7)
2227 #define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8)
2228 #define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9)
2229 #define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10)
2230 #define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11)
2231 #define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12)
2232 #define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13)
2233 #define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14)
2234 #define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15)
2235 #define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16)
2236 #define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17)
2237 #define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18)
2238 #define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19)
2239 #define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20)
2240 #define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21)
2241 #define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22)
2242 #define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23)
2243 #define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24)
2244 #define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25)
2245 #define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26)
2246 #define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27)
2247 #define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28)
2248 #define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29)
2249 #define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30)
2250 #define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31)
2251 #define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32)
2252 #define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33)
2253 #define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34)
2254 #define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35)
2255 #define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36)
2256 #define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37)
2257 #define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38)
2258 #define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39)
2259 #define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40)
2260 #define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41)
2261 #define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42)
2262 #define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43)
2263 #define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44)
2264 #define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45)
2265 #define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46)
2266 #define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47)
2267 #define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48)
2268 #define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49)
2269 #define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50)
2270 #define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51)
2271 #define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52)
2272 #define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53)
2273 #define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54)
2274 #define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55)
2275 #define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56)
2276 #define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57)
2277 #define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58)
2278 #define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59)
2279 #define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60)
2280 #define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61)
2281 #define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62)
2282 #define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63)
2283 
2284 #define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1;
2285 #define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1);
2286 
2287 /*!
2288 @brief macro
2289 @def NLOHMANN_DEFINE_TYPE_INTRUSIVE
2290 @since version 3.9.0
2291 */
2292 #define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \
2293  friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2294  friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2295 
2296 /*!
2297 @brief macro
2298 @def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE
2299 @since version 3.9.0
2300 */
2301 #define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \
2302  inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \
2303  inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) }
2304 
2305 #ifndef JSON_USE_IMPLICIT_CONVERSIONS
2306  #define JSON_USE_IMPLICIT_CONVERSIONS 1
2307 #endif
2308 
2309 #if JSON_USE_IMPLICIT_CONVERSIONS
2310  #define JSON_EXPLICIT
2311 #else
2312  #define JSON_EXPLICIT explicit
2313 #endif
2314 
2315 
2316 namespace nlohmann
2317 {
2318 namespace detail
2319 {
2320 ////////////////
2321 // exceptions //
2322 ////////////////
2323 
2324 /*!
2325 @brief general exception of the @ref basic_json class
2326 
2327 This class is an extension of `std::exception` objects with a member @a id for
2328 exception ids. It is used as the base class for all exceptions thrown by the
2329 @ref basic_json class. This class can hence be used as "wildcard" to catch
2330 exceptions.
2331 
2332 Subclasses:
2333 - @ref parse_error for exceptions indicating a parse error
2334 - @ref invalid_iterator for exceptions indicating errors with iterators
2335 - @ref type_error for exceptions indicating executing a member function with
2336  a wrong type
2337 - @ref out_of_range for exceptions indicating access out of the defined range
2338 - @ref other_error for exceptions indicating other library errors
2339 
2340 @internal
2341 @note To have nothrow-copy-constructible exceptions, we internally use
2342  `std::runtime_error` which can cope with arbitrary-length error messages.
2343  Intermediate strings are built with static functions and then passed to
2344  the actual constructor.
2345 @endinternal
2346 
2347 @liveexample{The following code shows how arbitrary library exceptions can be
2348 caught.,exception}
2349 
2350 @since version 3.0.0
2351 */
2352 class exception : public std::exception
2353 {
2354  public:
2355  /// returns the explanatory string
2356  JSON_HEDLEY_RETURNS_NON_NULL
2357  const char* what() const noexcept override
2358  {
2359  return m.what();
2360  }
2361 
2362  /// the id of the exception
2363  const int id;
2364 
2365  protected:
2366  JSON_HEDLEY_NON_NULL(3)
2367  exception(int id_, const char* what_arg) : id(id_), m(what_arg) {}
2368 
2369  static std::string name(const std::string& ename, int id_)
2370  {
2371  return "[json.exception." + ename + "." + std::to_string(id_) + "] ";
2372  }
2373 
2374  private:
2375  /// an exception object as storage for error messages
2376  std::runtime_error m;
2377 };
2378 
2379 /*!
2380 @brief exception indicating a parse error
2381 
2382 This exception is thrown by the library when a parse error occurs. Parse errors
2383 can occur during the deserialization of JSON text, CBOR, MessagePack, as well
2384 as when using JSON Patch.
2385 
2386 Member @a byte holds the byte index of the last read character in the input
2387 file.
2388 
2389 Exceptions have ids 1xx.
2390 
2391 name / id | example message | description
2392 ------------------------------ | --------------- | -------------------------
2393 json.exception.parse_error.101 | parse error at 2: unexpected end of input; expected string literal | This error indicates a syntax error while deserializing a JSON text. The error message describes that an unexpected token (character) was encountered, and the member @a byte indicates the error position.
2394 json.exception.parse_error.102 | parse error at 14: missing or wrong low surrogate | JSON uses the `\uxxxx` format to describe Unicode characters. Code points above above 0xFFFF are split into two `\uxxxx` entries ("surrogate pairs"). This error indicates that the surrogate pair is incomplete or contains an invalid code point.
2395 json.exception.parse_error.103 | parse error: code points above 0x10FFFF are invalid | Unicode supports code points up to 0x10FFFF. Code points above 0x10FFFF are invalid.
2396 json.exception.parse_error.104 | parse error: JSON patch must be an array of objects | [RFC 6902](https://tools.ietf.org/html/rfc6902) requires a JSON Patch document to be a JSON document that represents an array of objects.
2397 json.exception.parse_error.105 | parse error: operation must have string member 'op' | An operation of a JSON Patch document must contain exactly one "op" member, whose value indicates the operation to perform. Its value must be one of "add", "remove", "replace", "move", "copy", or "test"; other values are errors.
2398 json.exception.parse_error.106 | parse error: array index '01' must not begin with '0' | An array index in a JSON Pointer ([RFC 6901](https://tools.ietf.org/html/rfc6901)) may be `0` or any number without a leading `0`.
2399 json.exception.parse_error.107 | parse error: JSON pointer must be empty or begin with '/' - was: 'foo' | A JSON Pointer must be a Unicode string containing a sequence of zero or more reference tokens, each prefixed by a `/` character.
2400 json.exception.parse_error.108 | parse error: escape character '~' must be followed with '0' or '1' | In a JSON Pointer, only `~0` and `~1` are valid escape sequences.
2401 json.exception.parse_error.109 | parse error: array index 'one' is not a number | A JSON Pointer array index must be a number.
2402 json.exception.parse_error.110 | parse error at 1: cannot read 2 bytes from vector | When parsing CBOR or MessagePack, the byte vector ends before the complete value has been read.
2403 json.exception.parse_error.112 | parse error at 1: error reading CBOR; last byte: 0xF8 | Not all types of CBOR or MessagePack are supported. This exception occurs if an unsupported byte was read.
2404 json.exception.parse_error.113 | parse error at 2: expected a CBOR string; last byte: 0x98 | While parsing a map key, a value that is not a string has been read.
2405 json.exception.parse_error.114 | parse error: Unsupported BSON record type 0x0F | The parsing of the corresponding BSON record type is not implemented (yet).
2406 json.exception.parse_error.115 | parse error at byte 5: syntax error while parsing UBJSON high-precision number: invalid number text: 1A | A UBJSON high-precision number could not be parsed.
2407 
2408 @note For an input with n bytes, 1 is the index of the first character and n+1
2409  is the index of the terminating null byte or the end of file. This also
2410  holds true when reading a byte vector (CBOR or MessagePack).
2411 
2412 @liveexample{The following code shows how a `parse_error` exception can be
2413 caught.,parse_error}
2414 
2415 @sa - @ref exception for the base class of the library exceptions
2416 @sa - @ref invalid_iterator for exceptions indicating errors with iterators
2417 @sa - @ref type_error for exceptions indicating executing a member function with
2418  a wrong type
2419 @sa - @ref out_of_range for exceptions indicating access out of the defined range
2420 @sa - @ref other_error for exceptions indicating other library errors
2421 
2422 @since version 3.0.0
2423 */
2424 class parse_error : public exception
2425 {
2426  public:
2427  /*!
2428  @brief create a parse error exception
2429  @param[in] id_ the id of the exception
2430  @param[in] pos the position where the error occurred (or with
2431  chars_read_total=0 if the position cannot be
2432  determined)
2433  @param[in] what_arg the explanatory string
2434  @return parse_error object
2435  */
2436  static parse_error create(int id_, const position_t& pos, const std::string& what_arg)
2437  {
2438  std::string w = exception::name("parse_error", id_) + "parse error" +
2439  position_string(pos) + ": " + what_arg;
2440  return parse_error(id_, pos.chars_read_total, w.c_str());
2441  }
2442 
2443  static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
2444  {
2445  std::string w = exception::name("parse_error", id_) + "parse error" +
2446  (byte_ != 0 ? (" at byte " + std::to_string(byte_)) : "") +
2447  ": " + what_arg;
2448  return parse_error(id_, byte_, w.c_str());
2449  }
2450 
2451  /*!
2452  @brief byte index of the parse error
2453 
2454  The byte index of the last read character in the input file.
2455 
2456  @note For an input with n bytes, 1 is the index of the first character and
2457  n+1 is the index of the terminating null byte or the end of file.
2458  This also holds true when reading a byte vector (CBOR or MessagePack).
2459  */
2460  const std::size_t byte;
2461 
2462  private:
2463  parse_error(int id_, std::size_t byte_, const char* what_arg)
2464  : exception(id_, what_arg), byte(byte_) {}
2465 
2466  static std::string position_string(const position_t& pos)
2467  {
2468  return " at line " + std::to_string(pos.lines_read + 1) +
2469  ", column " + std::to_string(pos.chars_read_current_line);
2470  }
2471 };
2472 
2473 /*!
2474 @brief exception indicating errors with iterators
2475 
2476 This exception is thrown if iterators passed to a library function do not match
2477 the expected semantics.
2478 
2479 Exceptions have ids 2xx.
2480 
2481 name / id | example message | description
2482 ----------------------------------- | --------------- | -------------------------
2483 json.exception.invalid_iterator.201 | iterators are not compatible | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
2484 json.exception.invalid_iterator.202 | iterator does not fit current value | In an erase or insert function, the passed iterator @a pos does not belong to the JSON value for which the function was called. It hence does not define a valid position for the deletion/insertion.
2485 json.exception.invalid_iterator.203 | iterators do not fit current value | Either iterator passed to function @ref erase(IteratorType first, IteratorType last) does not belong to the JSON value from which values shall be erased. It hence does not define a valid range to delete values from.
2486 json.exception.invalid_iterator.204 | iterators out of range | When an iterator range for a primitive type (number, boolean, or string) is passed to a constructor or an erase function, this range has to be exactly (@ref begin(), @ref end()), because this is the only way the single stored value is expressed. All other ranges are invalid.
2487 json.exception.invalid_iterator.205 | iterator out of range | When an iterator for a primitive type (number, boolean, or string) is passed to an erase function, the iterator has to be the @ref begin() iterator, because it is the only way to address the stored value. All other iterators are invalid.
2488 json.exception.invalid_iterator.206 | cannot construct with iterators from null | The iterators passed to constructor @ref basic_json(InputIT first, InputIT last) belong to a JSON null value and hence to not define a valid range.
2489 json.exception.invalid_iterator.207 | cannot use key() for non-object iterators | The key() member function can only be used on iterators belonging to a JSON object, because other types do not have a concept of a key.
2490 json.exception.invalid_iterator.208 | cannot use operator[] for object iterators | The operator[] to specify a concrete offset cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
2491 json.exception.invalid_iterator.209 | cannot use offsets with object iterators | The offset operators (+, -, +=, -=) cannot be used on iterators belonging to a JSON object, because JSON objects are unordered.
2492 json.exception.invalid_iterator.210 | iterators do not fit | The iterator range passed to the insert function are not compatible, meaning they do not belong to the same container. Therefore, the range (@a first, @a last) is invalid.
2493 json.exception.invalid_iterator.211 | passed iterators may not belong to container | The iterator range passed to the insert function must not be a subrange of the container to insert to.
2494 json.exception.invalid_iterator.212 | cannot compare iterators of different containers | When two iterators are compared, they must belong to the same container.
2495 json.exception.invalid_iterator.213 | cannot compare order of object iterators | The order of object iterators cannot be compared, because JSON objects are unordered.
2496 json.exception.invalid_iterator.214 | cannot get value | Cannot get value for iterator: Either the iterator belongs to a null value or it is an iterator to a primitive type (number, boolean, or string), but the iterator is different to @ref begin().
2497 
2498 @liveexample{The following code shows how an `invalid_iterator` exception can be
2499 caught.,invalid_iterator}
2500 
2501 @sa - @ref exception for the base class of the library exceptions
2502 @sa - @ref parse_error for exceptions indicating a parse error
2503 @sa - @ref type_error for exceptions indicating executing a member function with
2504  a wrong type
2505 @sa - @ref out_of_range for exceptions indicating access out of the defined range
2506 @sa - @ref other_error for exceptions indicating other library errors
2507 
2508 @since version 3.0.0
2509 */
2511 {
2512  public:
2513  static invalid_iterator create(int id_, const std::string& what_arg)
2514  {
2515  std::string w = exception::name("invalid_iterator", id_) + what_arg;
2516  return invalid_iterator(id_, w.c_str());
2517  }
2518 
2519  private:
2520  JSON_HEDLEY_NON_NULL(3)
2521  invalid_iterator(int id_, const char* what_arg)
2522  : exception(id_, what_arg) {}
2523 };
2524 
2525 /*!
2526 @brief exception indicating executing a member function with a wrong type
2527 
2528 This exception is thrown in case of a type error; that is, a library function is
2529 executed on a JSON value whose type does not match the expected semantics.
2530 
2531 Exceptions have ids 3xx.
2532 
2533 name / id | example message | description
2534 ----------------------------- | --------------- | -------------------------
2535 json.exception.type_error.301 | cannot create object from initializer list | To create an object from an initializer list, the initializer list must consist only of a list of pairs whose first element is a string. When this constraint is violated, an array is created instead.
2536 json.exception.type_error.302 | type must be object, but is array | During implicit or explicit value conversion, the JSON type must be compatible to the target type. For instance, a JSON string can only be converted into string types, but not into numbers or boolean types.
2537 json.exception.type_error.303 | incompatible ReferenceType for get_ref, actual type is object | To retrieve a reference to a value stored in a @ref basic_json object with @ref get_ref, the type of the reference must match the value type. For instance, for a JSON array, the @a ReferenceType must be @ref array_t &.
2538 json.exception.type_error.304 | cannot use at() with string | The @ref at() member functions can only be executed for certain JSON types.
2539 json.exception.type_error.305 | cannot use operator[] with string | The @ref operator[] member functions can only be executed for certain JSON types.
2540 json.exception.type_error.306 | cannot use value() with string | The @ref value() member functions can only be executed for certain JSON types.
2541 json.exception.type_error.307 | cannot use erase() with string | The @ref erase() member functions can only be executed for certain JSON types.
2542 json.exception.type_error.308 | cannot use push_back() with string | The @ref push_back() and @ref operator+= member functions can only be executed for certain JSON types.
2543 json.exception.type_error.309 | cannot use insert() with | The @ref insert() member functions can only be executed for certain JSON types.
2544 json.exception.type_error.310 | cannot use swap() with number | The @ref swap() member functions can only be executed for certain JSON types.
2545 json.exception.type_error.311 | cannot use emplace_back() with string | The @ref emplace_back() member function can only be executed for certain JSON types.
2546 json.exception.type_error.312 | cannot use update() with string | The @ref update() member functions can only be executed for certain JSON types.
2547 json.exception.type_error.313 | invalid value to unflatten | The @ref unflatten function converts an object whose keys are JSON Pointers back into an arbitrary nested JSON value. The JSON Pointers must not overlap, because then the resulting value would not be well defined.
2548 json.exception.type_error.314 | only objects can be unflattened | The @ref unflatten function only works for an object whose keys are JSON Pointers.
2549 json.exception.type_error.315 | values in object must be primitive | The @ref unflatten function only works for an object whose keys are JSON Pointers and whose values are primitive.
2550 json.exception.type_error.316 | invalid UTF-8 byte at index 10: 0x7E | The @ref dump function only works with UTF-8 encoded strings; that is, if you assign a `std::string` to a JSON value, make sure it is UTF-8 encoded. |
2551 json.exception.type_error.317 | JSON value cannot be serialized to requested format | The dynamic type of the object cannot be represented in the requested serialization format (e.g. a raw `true` or `null` JSON object cannot be serialized to BSON) |
2552 
2553 @liveexample{The following code shows how a `type_error` exception can be
2554 caught.,type_error}
2555 
2556 @sa - @ref exception for the base class of the library exceptions
2557 @sa - @ref parse_error for exceptions indicating a parse error
2558 @sa - @ref invalid_iterator for exceptions indicating errors with iterators
2559 @sa - @ref out_of_range for exceptions indicating access out of the defined range
2560 @sa - @ref other_error for exceptions indicating other library errors
2561 
2562 @since version 3.0.0
2563 */
2564 class type_error : public exception
2565 {
2566  public:
2567  static type_error create(int id_, const std::string& what_arg)
2568  {
2569  std::string w = exception::name("type_error", id_) + what_arg;
2570  return type_error(id_, w.c_str());
2571  }
2572 
2573  private:
2574  JSON_HEDLEY_NON_NULL(3)
2575  type_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
2576 };
2577 
2578 /*!
2579 @brief exception indicating access out of the defined range
2580 
2581 This exception is thrown in case a library function is called on an input
2582 parameter that exceeds the expected range, for instance in case of array
2583 indices or nonexisting object keys.
2584 
2585 Exceptions have ids 4xx.
2586 
2587 name / id | example message | description
2588 ------------------------------- | --------------- | -------------------------
2589 json.exception.out_of_range.401 | array index 3 is out of range | The provided array index @a i is larger than @a size-1.
2590 json.exception.out_of_range.402 | array index '-' (3) is out of range | The special array index `-` in a JSON Pointer never describes a valid element of the array, but the index past the end. That is, it can only be used to add elements at this position, but not to read it.
2591 json.exception.out_of_range.403 | key 'foo' not found | The provided key was not found in the JSON object.
2592 json.exception.out_of_range.404 | unresolved reference token 'foo' | A reference token in a JSON Pointer could not be resolved.
2593 json.exception.out_of_range.405 | JSON pointer has no parent | The JSON Patch operations 'remove' and 'add' can not be applied to the root element of the JSON value.
2594 json.exception.out_of_range.406 | number overflow parsing '10E1000' | A parsed number could not be stored as without changing it to NaN or INF.
2595 json.exception.out_of_range.407 | number overflow serializing '9223372036854775808' | UBJSON and BSON only support integer numbers up to 9223372036854775807. (until version 3.8.0) |
2596 json.exception.out_of_range.408 | excessive array size: 8658170730974374167 | The size (following `#`) of an UBJSON array or object exceeds the maximal capacity. |
2597 json.exception.out_of_range.409 | BSON key cannot contain code point U+0000 (at byte 2) | Key identifiers to be serialized to BSON cannot contain code point U+0000, since the key is stored as zero-terminated c-string |
2598 
2599 @liveexample{The following code shows how an `out_of_range` exception can be
2600 caught.,out_of_range}
2601 
2602 @sa - @ref exception for the base class of the library exceptions
2603 @sa - @ref parse_error for exceptions indicating a parse error
2604 @sa - @ref invalid_iterator for exceptions indicating errors with iterators
2605 @sa - @ref type_error for exceptions indicating executing a member function with
2606  a wrong type
2607 @sa - @ref other_error for exceptions indicating other library errors
2608 
2609 @since version 3.0.0
2610 */
2611 class out_of_range : public exception
2612 {
2613  public:
2614  static out_of_range create(int id_, const std::string& what_arg)
2615  {
2616  std::string w = exception::name("out_of_range", id_) + what_arg;
2617  return out_of_range(id_, w.c_str());
2618  }
2619 
2620  private:
2621  JSON_HEDLEY_NON_NULL(3)
2622  out_of_range(int id_, const char* what_arg) : exception(id_, what_arg) {}
2623 };
2624 
2625 /*!
2626 @brief exception indicating other library errors
2627 
2628 This exception is thrown in case of errors that cannot be classified with the
2629 other exception types.
2630 
2631 Exceptions have ids 5xx.
2632 
2633 name / id | example message | description
2634 ------------------------------ | --------------- | -------------------------
2635 json.exception.other_error.501 | unsuccessful: {"op":"test","path":"/baz", "value":"bar"} | A JSON Patch operation 'test' failed. The unsuccessful operation is also printed.
2636 
2637 @sa - @ref exception for the base class of the library exceptions
2638 @sa - @ref parse_error for exceptions indicating a parse error
2639 @sa - @ref invalid_iterator for exceptions indicating errors with iterators
2640 @sa - @ref type_error for exceptions indicating executing a member function with
2641  a wrong type
2642 @sa - @ref out_of_range for exceptions indicating access out of the defined range
2643 
2644 @liveexample{The following code shows how an `other_error` exception can be
2645 caught.,other_error}
2646 
2647 @since version 3.0.0
2648 */
2649 class other_error : public exception
2650 {
2651  public:
2652  static other_error create(int id_, const std::string& what_arg)
2653  {
2654  std::string w = exception::name("other_error", id_) + what_arg;
2655  return other_error(id_, w.c_str());
2656  }
2657 
2658  private:
2659  JSON_HEDLEY_NON_NULL(3)
2660  other_error(int id_, const char* what_arg) : exception(id_, what_arg) {}
2661 };
2662 } // namespace detail
2663 } // namespace nlohmann
2664 
2665 // #include <nlohmann/detail/macro_scope.hpp>
2666 
2667 // #include <nlohmann/detail/meta/cpp_future.hpp>
2668 
2669 
2670 #include <cstddef> // size_t
2671 #include <type_traits> // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type
2672 
2673 namespace nlohmann
2674 {
2675 namespace detail
2676 {
2677 // alias templates to reduce boilerplate
2678 template<bool B, typename T = void>
2679 using enable_if_t = typename std::enable_if<B, T>::type;
2680 
2681 template<typename T>
2682 using uncvref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
2683 
2684 // implementation of C++14 index_sequence and affiliates
2685 // source: https://stackoverflow.com/a/32223343
2686 template<std::size_t... Ints>
2688 {
2689  using type = index_sequence;
2690  using value_type = std::size_t;
2691  static constexpr std::size_t size() noexcept
2692  {
2693  return sizeof...(Ints);
2694  }
2695 };
2696 
2697 template<class Sequence1, class Sequence2>
2699 
2700 template<std::size_t... I1, std::size_t... I2>
2702  : index_sequence < I1..., (sizeof...(I1) + I2)... > {};
2703 
2704 template<std::size_t N>
2706  : merge_and_renumber < typename make_index_sequence < N / 2 >::type,
2707  typename make_index_sequence < N - N / 2 >::type > {};
2708 
2709 template<> struct make_index_sequence<0> : index_sequence<> {};
2710 template<> struct make_index_sequence<1> : index_sequence<0> {};
2711 
2712 template<typename... Ts>
2713 using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
2714 
2715 // dispatch utility (taken from ranges-v3)
2716 template<unsigned N> struct priority_tag : priority_tag < N - 1 > {};
2717 template<> struct priority_tag<0> {};
2718 
2719 // taken from ranges-v3
2720 template<typename T>
2722 {
2723  static constexpr T value{};
2724 };
2725 
2726 template<typename T>
2727 constexpr T static_const<T>::value;
2728 } // namespace detail
2729 } // namespace nlohmann
2730 
2731 // #include <nlohmann/detail/meta/type_traits.hpp>
2732 
2733 
2734 #include <limits> // numeric_limits
2735 #include <type_traits> // false_type, is_constructible, is_integral, is_same, true_type
2736 #include <utility> // declval
2737 
2738 // #include <nlohmann/detail/iterators/iterator_traits.hpp>
2739 
2740 
2741 #include <iterator> // random_access_iterator_tag
2742 
2743 // #include <nlohmann/detail/meta/void_t.hpp>
2744 
2745 
2746 namespace nlohmann
2747 {
2748 namespace detail
2749 {
2750 template<typename ...Ts> struct make_void
2751 {
2752  using type = void;
2753 };
2754 template<typename ...Ts> using void_t = typename make_void<Ts...>::type;
2755 } // namespace detail
2756 } // namespace nlohmann
2757 
2758 // #include <nlohmann/detail/meta/cpp_future.hpp>
2759 
2760 
2761 namespace nlohmann
2762 {
2763 namespace detail
2764 {
2765 template<typename It, typename = void>
2766 struct iterator_types {};
2767 
2768 template<typename It>
2770  It,
2771  void_t<typename It::difference_type, typename It::value_type, typename It::pointer,
2772  typename It::reference, typename It::iterator_category >>
2773 {
2774  using difference_type = typename It::difference_type;
2775  using value_type = typename It::value_type;
2776  using pointer = typename It::pointer;
2777  using reference = typename It::reference;
2778  using iterator_category = typename It::iterator_category;
2779 };
2780 
2781 // This is required as some compilers implement std::iterator_traits in a way that
2782 // doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341.
2783 template<typename T, typename = void>
2785 {
2786 };
2787 
2788 template<typename T>
2789 struct iterator_traits < T, enable_if_t < !std::is_pointer<T>::value >>
2790  : iterator_types<T>
2791 {
2792 };
2793 
2794 template<typename T>
2795 struct iterator_traits<T*, enable_if_t<std::is_object<T>::value>>
2796 {
2797  using iterator_category = std::random_access_iterator_tag;
2798  using value_type = T;
2799  using difference_type = ptrdiff_t;
2800  using pointer = T*;
2801  using reference = T&;
2802 };
2803 } // namespace detail
2804 } // namespace nlohmann
2805 
2806 // #include <nlohmann/detail/macro_scope.hpp>
2807 
2808 // #include <nlohmann/detail/meta/cpp_future.hpp>
2809 
2810 // #include <nlohmann/detail/meta/detected.hpp>
2811 
2812 
2813 #include <type_traits>
2814 
2815 // #include <nlohmann/detail/meta/void_t.hpp>
2816 
2817 
2818 // https://en.cppreference.com/w/cpp/experimental/is_detected
2819 namespace nlohmann
2820 {
2821 namespace detail
2822 {
2823 struct nonesuch
2824 {
2825  nonesuch() = delete;
2826  ~nonesuch() = delete;
2827  nonesuch(nonesuch const&) = delete;
2828  nonesuch(nonesuch const&&) = delete;
2829  void operator=(nonesuch const&) = delete;
2830  void operator=(nonesuch&&) = delete;
2831 };
2832 
2833 template<class Default,
2834  class AlwaysVoid,
2835  template<class...> class Op,
2836  class... Args>
2837 struct detector
2838 {
2839  using value_t = std::false_type;
2840  using type = Default;
2841 };
2842 
2843 template<class Default, template<class...> class Op, class... Args>
2844 struct detector<Default, void_t<Op<Args...>>, Op, Args...>
2845 {
2846  using value_t = std::true_type;
2847  using type = Op<Args...>;
2848 };
2849 
2850 template<template<class...> class Op, class... Args>
2851 using is_detected = typename detector<nonesuch, void, Op, Args...>::value_t;
2852 
2853 template<template<class...> class Op, class... Args>
2854 using detected_t = typename detector<nonesuch, void, Op, Args...>::type;
2855 
2856 template<class Default, template<class...> class Op, class... Args>
2857 using detected_or = detector<Default, void, Op, Args...>;
2858 
2859 template<class Default, template<class...> class Op, class... Args>
2860 using detected_or_t = typename detected_or<Default, Op, Args...>::type;
2861 
2862 template<class Expected, template<class...> class Op, class... Args>
2863 using is_detected_exact = std::is_same<Expected, detected_t<Op, Args...>>;
2864 
2865 template<class To, template<class...> class Op, class... Args>
2866 using is_detected_convertible =
2867  std::is_convertible<detected_t<Op, Args...>, To>;
2868 } // namespace detail
2869 } // namespace nlohmann
2870 
2871 // #include <nlohmann/json_fwd.hpp>
2872 #ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_
2873 #define INCLUDE_NLOHMANN_JSON_FWD_HPP_
2874 
2875 #include <cstdint> // int64_t, uint64_t
2876 #include <map> // map
2877 #include <memory> // allocator
2878 #include <string> // string
2879 #include <vector> // vector
2880 
2881 /*!
2882 @brief namespace for Niels Lohmann
2883 @see https://github.com/nlohmann
2884 @since version 1.0.0
2885 */
2886 namespace nlohmann
2887 {
2888 /*!
2889 @brief default JSONSerializer template argument
2890 
2891 This serializer ignores the template arguments and uses ADL
2892 ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl))
2893 for serialization.
2894 */
2895 template<typename T = void, typename SFINAE = void>
2896 struct adl_serializer;
2897 
2898 template<template<typename U, typename V, typename... Args> class ObjectType =
2899  std::map,
2900  template<typename U, typename... Args> class ArrayType = std::vector,
2901  class StringType = std::string, class BooleanType = bool,
2902  class NumberIntegerType = std::int64_t,
2903  class NumberUnsignedType = std::uint64_t,
2904  class NumberFloatType = double,
2905  template<typename U> class AllocatorType = std::allocator,
2906  template<typename T, typename SFINAE = void> class JSONSerializer =
2907  adl_serializer,
2908  class BinaryType = std::vector<std::uint8_t>>
2909 class basic_json;
2910 
2911 /*!
2912 @brief JSON Pointer
2913 
2914 A JSON pointer defines a string syntax for identifying a specific value
2915 within a JSON document. It can be used with functions `at` and
2916 `operator[]`. Furthermore, JSON pointers are the base for JSON patches.
2917 
2918 @sa [RFC 6901](https://tools.ietf.org/html/rfc6901)
2919 
2920 @since version 2.0.0
2921 */
2922 template<typename BasicJsonType>
2923 class json_pointer;
2924 
2925 /*!
2926 @brief default JSON class
2927 
2928 This type is the default specialization of the @ref basic_json class which
2929 uses the standard template types.
2930 
2931 @since version 1.0.0
2932 */
2934 
2935 template<class Key, class T, class IgnoredLess, class Allocator>
2936 struct ordered_map;
2937 
2938 /*!
2939 @brief ordered JSON class
2940 
2941 This type preserves the insertion order of object keys.
2942 
2943 @since version 3.9.0
2944 */
2946 
2947 } // namespace nlohmann
2948 
2949 #endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_
2950 
2951 
2952 namespace nlohmann
2953 {
2954 /*!
2955 @brief detail namespace with internal helper functions
2956 
2957 This namespace collects functions that should not be exposed,
2958 implementations of some @ref basic_json methods, and meta-programming helpers.
2959 
2960 @since version 2.1.0
2961 */
2962 namespace detail
2963 {
2964 /////////////
2965 // helpers //
2966 /////////////
2967 
2968 // Note to maintainers:
2969 //
2970 // Every trait in this file expects a non CV-qualified type.
2971 // The only exceptions are in the 'aliases for detected' section
2972 // (i.e. those of the form: decltype(T::member_function(std::declval<T>())))
2973 //
2974 // In this case, T has to be properly CV-qualified to constraint the function arguments
2975 // (e.g. to_json(BasicJsonType&, const T&))
2976 
2977 template<typename> struct is_basic_json : std::false_type {};
2978 
2979 NLOHMANN_BASIC_JSON_TPL_DECLARATION
2980 struct is_basic_json<NLOHMANN_BASIC_JSON_TPL> : std::true_type {};
2981 
2982 //////////////////////
2983 // json_ref helpers //
2984 //////////////////////
2985 
2986 template<typename>
2987 class json_ref;
2988 
2989 template<typename>
2990 struct is_json_ref : std::false_type {};
2991 
2992 template<typename T>
2993 struct is_json_ref<json_ref<T>> : std::true_type {};
2994 
2995 //////////////////////////
2996 // aliases for detected //
2997 //////////////////////////
2998 
2999 template<typename T>
3000 using mapped_type_t = typename T::mapped_type;
3001 
3002 template<typename T>
3003 using key_type_t = typename T::key_type;
3004 
3005 template<typename T>
3006 using value_type_t = typename T::value_type;
3007 
3008 template<typename T>
3009 using difference_type_t = typename T::difference_type;
3010 
3011 template<typename T>
3012 using pointer_t = typename T::pointer;
3013 
3014 template<typename T>
3015 using reference_t = typename T::reference;
3016 
3017 template<typename T>
3018 using iterator_category_t = typename T::iterator_category;
3019 
3020 template<typename T>
3021 using iterator_t = typename T::iterator;
3022 
3023 template<typename T, typename... Args>
3024 using to_json_function = decltype(T::to_json(std::declval<Args>()...));
3025 
3026 template<typename T, typename... Args>
3027 using from_json_function = decltype(T::from_json(std::declval<Args>()...));
3028 
3029 template<typename T, typename U>
3030 using get_template_function = decltype(std::declval<T>().template get<U>());
3031 
3032 // trait checking if JSONSerializer<T>::from_json(json const&, udt&) exists
3033 template<typename BasicJsonType, typename T, typename = void>
3034 struct has_from_json : std::false_type {};
3035 
3036 // trait checking if j.get<T> is valid
3037 // use this trait instead of std::is_constructible or std::is_convertible,
3038 // both rely on, or make use of implicit conversions, and thus fail when T
3039 // has several constructors/operator= (see https://github.com/nlohmann/json/issues/958)
3040 template <typename BasicJsonType, typename T>
3042 {
3043  static constexpr bool value = is_detected<get_template_function, const BasicJsonType&, T>::value;
3044 };
3045 
3046 template<typename BasicJsonType, typename T>
3047 struct has_from_json < BasicJsonType, T,
3048  enable_if_t < !is_basic_json<T>::value >>
3049 {
3050  using serializer = typename BasicJsonType::template json_serializer<T, void>;
3051 
3052  static constexpr bool value =
3053  is_detected_exact<void, from_json_function, serializer,
3054  const BasicJsonType&, T&>::value;
3055 };
3056 
3057 // This trait checks if JSONSerializer<T>::from_json(json const&) exists
3058 // this overload is used for non-default-constructible user-defined-types
3059 template<typename BasicJsonType, typename T, typename = void>
3060 struct has_non_default_from_json : std::false_type {};
3061 
3062 template<typename BasicJsonType, typename T>
3063 struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3064 {
3065  using serializer = typename BasicJsonType::template json_serializer<T, void>;
3066 
3067  static constexpr bool value =
3068  is_detected_exact<T, from_json_function, serializer,
3069  const BasicJsonType&>::value;
3070 };
3071 
3072 // This trait checks if BasicJsonType::json_serializer<T>::to_json exists
3073 // Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion.
3074 template<typename BasicJsonType, typename T, typename = void>
3075 struct has_to_json : std::false_type {};
3076 
3077 template<typename BasicJsonType, typename T>
3078 struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json<T>::value >>
3079 {
3080  using serializer = typename BasicJsonType::template json_serializer<T, void>;
3081 
3082  static constexpr bool value =
3083  is_detected_exact<void, to_json_function, serializer, BasicJsonType&,
3084  T>::value;
3085 };
3086 
3087 
3088 ///////////////////
3089 // is_ functions //
3090 ///////////////////
3091 
3092 template<typename T, typename = void>
3093 struct is_iterator_traits : std::false_type {};
3094 
3095 template<typename T>
3097 {
3098  private:
3099  using traits = iterator_traits<T>;
3100 
3101  public:
3102  static constexpr auto value =
3103  is_detected<value_type_t, traits>::value &&
3104  is_detected<difference_type_t, traits>::value &&
3105  is_detected<pointer_t, traits>::value &&
3106  is_detected<iterator_category_t, traits>::value &&
3107  is_detected<reference_t, traits>::value;
3108 };
3109 
3110 // source: https://stackoverflow.com/a/37193089/4116453
3111 
3112 template<typename T, typename = void>
3113 struct is_complete_type : std::false_type {};
3114 
3115 template<typename T>
3116 struct is_complete_type<T, decltype(void(sizeof(T)))> : std::true_type {};
3117 
3118 template<typename BasicJsonType, typename CompatibleObjectType,
3119  typename = void>
3120 struct is_compatible_object_type_impl : std::false_type {};
3121 
3122 template<typename BasicJsonType, typename CompatibleObjectType>
3124  BasicJsonType, CompatibleObjectType,
3125  enable_if_t < is_detected<mapped_type_t, CompatibleObjectType>::value&&
3126  is_detected<key_type_t, CompatibleObjectType>::value >>
3127 {
3128 
3129  using object_t = typename BasicJsonType::object_t;
3130 
3131  // macOS's is_constructible does not play well with nonesuch...
3132  static constexpr bool value =
3133  std::is_constructible<typename object_t::key_type,
3134  typename CompatibleObjectType::key_type>::value &&
3135  std::is_constructible<typename object_t::mapped_type,
3136  typename CompatibleObjectType::mapped_type>::value;
3137 };
3138 
3139 template<typename BasicJsonType, typename CompatibleObjectType>
3141  : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};
3142 
3143 template<typename BasicJsonType, typename ConstructibleObjectType,
3144  typename = void>
3145 struct is_constructible_object_type_impl : std::false_type {};
3146 
3147 template<typename BasicJsonType, typename ConstructibleObjectType>
3149  BasicJsonType, ConstructibleObjectType,
3150  enable_if_t < is_detected<mapped_type_t, ConstructibleObjectType>::value&&
3151  is_detected<key_type_t, ConstructibleObjectType>::value >>
3152 {
3153  using object_t = typename BasicJsonType::object_t;
3154 
3155  static constexpr bool value =
3156  (std::is_default_constructible<ConstructibleObjectType>::value &&
3157  (std::is_move_assignable<ConstructibleObjectType>::value ||
3158  std::is_copy_assignable<ConstructibleObjectType>::value) &&
3159  (std::is_constructible<typename ConstructibleObjectType::key_type,
3160  typename object_t::key_type>::value &&
3161  std::is_same <
3162  typename object_t::mapped_type,
3163  typename ConstructibleObjectType::mapped_type >::value)) ||
3164  (has_from_json<BasicJsonType,
3165  typename ConstructibleObjectType::mapped_type>::value ||
3167  BasicJsonType,
3168  typename ConstructibleObjectType::mapped_type >::value);
3169 };
3170 
3171 template<typename BasicJsonType, typename ConstructibleObjectType>
3173  : is_constructible_object_type_impl<BasicJsonType,
3174  ConstructibleObjectType> {};
3175 
3176 template<typename BasicJsonType, typename CompatibleStringType,
3177  typename = void>
3178 struct is_compatible_string_type_impl : std::false_type {};
3179 
3180 template<typename BasicJsonType, typename CompatibleStringType>
3182  BasicJsonType, CompatibleStringType,
3183  enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
3184  value_type_t, CompatibleStringType>::value >>
3185 {
3186  static constexpr auto value =
3187  std::is_constructible<typename BasicJsonType::string_t, CompatibleStringType>::value;
3188 };
3189 
3190 template<typename BasicJsonType, typename ConstructibleStringType>
3192  : is_compatible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
3193 
3194 template<typename BasicJsonType, typename ConstructibleStringType,
3195  typename = void>
3196 struct is_constructible_string_type_impl : std::false_type {};
3197 
3198 template<typename BasicJsonType, typename ConstructibleStringType>
3200  BasicJsonType, ConstructibleStringType,
3201  enable_if_t<is_detected_exact<typename BasicJsonType::string_t::value_type,
3202  value_type_t, ConstructibleStringType>::value >>
3203 {
3204  static constexpr auto value =
3205  std::is_constructible<ConstructibleStringType,
3206  typename BasicJsonType::string_t>::value;
3207 };
3208 
3209 template<typename BasicJsonType, typename ConstructibleStringType>
3211  : is_constructible_string_type_impl<BasicJsonType, ConstructibleStringType> {};
3212 
3213 template<typename BasicJsonType, typename CompatibleArrayType, typename = void>
3214 struct is_compatible_array_type_impl : std::false_type {};
3215 
3216 template<typename BasicJsonType, typename CompatibleArrayType>
3218  BasicJsonType, CompatibleArrayType,
3219  enable_if_t < is_detected<value_type_t, CompatibleArrayType>::value&&
3220  is_detected<iterator_t, CompatibleArrayType>::value&&
3221 // This is needed because json_reverse_iterator has a ::iterator type...
3222 // Therefore it is detected as a CompatibleArrayType.
3223 // The real fix would be to have an Iterable concept.
3225  iterator_traits<CompatibleArrayType >>::value >>
3226 {
3227  static constexpr bool value =
3228  std::is_constructible<BasicJsonType,
3229  typename CompatibleArrayType::value_type>::value;
3230 };
3231 
3232 template<typename BasicJsonType, typename CompatibleArrayType>
3234  : is_compatible_array_type_impl<BasicJsonType, CompatibleArrayType> {};
3235 
3236 template<typename BasicJsonType, typename ConstructibleArrayType, typename = void>
3237 struct is_constructible_array_type_impl : std::false_type {};
3238 
3239 template<typename BasicJsonType, typename ConstructibleArrayType>
3241  BasicJsonType, ConstructibleArrayType,
3242  enable_if_t<std::is_same<ConstructibleArrayType,
3243  typename BasicJsonType::value_type>::value >>
3244  : std::true_type {};
3245 
3246 template<typename BasicJsonType, typename ConstructibleArrayType>
3248  BasicJsonType, ConstructibleArrayType,
3249  enable_if_t < !std::is_same<ConstructibleArrayType,
3250  typename BasicJsonType::value_type>::value&&
3251  std::is_default_constructible<ConstructibleArrayType>::value&&
3252 (std::is_move_assignable<ConstructibleArrayType>::value ||
3253  std::is_copy_assignable<ConstructibleArrayType>::value)&&
3254 is_detected<value_type_t, ConstructibleArrayType>::value&&
3255 is_detected<iterator_t, ConstructibleArrayType>::value&&
3257 detected_t<value_type_t, ConstructibleArrayType >>::value >>
3258 {
3259  static constexpr bool value =
3260  // This is needed because json_reverse_iterator has a ::iterator type,
3261  // furthermore, std::back_insert_iterator (and other iterators) have a
3262  // base class `iterator`... Therefore it is detected as a
3263  // ConstructibleArrayType. The real fix would be to have an Iterable
3264  // concept.
3266 
3267  (std::is_same<typename ConstructibleArrayType::value_type,
3268  typename BasicJsonType::array_t::value_type>::value ||
3269  has_from_json<BasicJsonType,
3270  typename ConstructibleArrayType::value_type>::value ||
3272  BasicJsonType, typename ConstructibleArrayType::value_type >::value);
3273 };
3274 
3275 template<typename BasicJsonType, typename ConstructibleArrayType>
3277  : is_constructible_array_type_impl<BasicJsonType, ConstructibleArrayType> {};
3278 
3279 template<typename RealIntegerType, typename CompatibleNumberIntegerType,
3280  typename = void>
3281 struct is_compatible_integer_type_impl : std::false_type {};
3282 
3283 template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3285  RealIntegerType, CompatibleNumberIntegerType,
3286  enable_if_t < std::is_integral<RealIntegerType>::value&&
3287  std::is_integral<CompatibleNumberIntegerType>::value&&
3288  !std::is_same<bool, CompatibleNumberIntegerType>::value >>
3289 {
3290  // is there an assert somewhere on overflows?
3291  using RealLimits = std::numeric_limits<RealIntegerType>;
3292  using CompatibleLimits = std::numeric_limits<CompatibleNumberIntegerType>;
3293 
3294  static constexpr auto value =
3295  std::is_constructible<RealIntegerType,
3296  CompatibleNumberIntegerType>::value &&
3297  CompatibleLimits::is_integer &&
3298  RealLimits::is_signed == CompatibleLimits::is_signed;
3299 };
3300 
3301 template<typename RealIntegerType, typename CompatibleNumberIntegerType>
3303  : is_compatible_integer_type_impl<RealIntegerType,
3304  CompatibleNumberIntegerType> {};
3305 
3306 template<typename BasicJsonType, typename CompatibleType, typename = void>
3307 struct is_compatible_type_impl: std::false_type {};
3308 
3309 template<typename BasicJsonType, typename CompatibleType>
3311  BasicJsonType, CompatibleType,
3312  enable_if_t<is_complete_type<CompatibleType>::value >>
3313 {
3314  static constexpr bool value =
3316 };
3317 
3318 template<typename BasicJsonType, typename CompatibleType>
3320  : is_compatible_type_impl<BasicJsonType, CompatibleType> {};
3321 
3322 // https://en.cppreference.com/w/cpp/types/conjunction
3323 template<class...> struct conjunction : std::true_type { };
3324 template<class B1> struct conjunction<B1> : B1 { };
3325 template<class B1, class... Bn>
3326 struct conjunction<B1, Bn...>
3327 : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
3328 
3329 template<typename T1, typename T2>
3330 struct is_constructible_tuple : std::false_type {};
3331 
3332 template<typename T1, typename... Args>
3333 struct is_constructible_tuple<T1, std::tuple<Args...>> : conjunction<std::is_constructible<T1, Args>...> {};
3334 } // namespace detail
3335 } // namespace nlohmann
3336 
3337 // #include <nlohmann/detail/value_t.hpp>
3338 
3339 
3340 #include <array> // array
3341 #include <cstddef> // size_t
3342 #include <cstdint> // uint8_t
3343 #include <string> // string
3344 
3345 namespace nlohmann
3346 {
3347 namespace detail
3348 {
3349 ///////////////////////////
3350 // JSON type enumeration //
3351 ///////////////////////////
3352 
3353 /*!
3354 @brief the JSON type enumeration
3355 
3356 This enumeration collects the different JSON types. It is internally used to
3357 distinguish the stored values, and the functions @ref basic_json::is_null(),
3358 @ref basic_json::is_object(), @ref basic_json::is_array(),
3359 @ref basic_json::is_string(), @ref basic_json::is_boolean(),
3360 @ref basic_json::is_number() (with @ref basic_json::is_number_integer(),
3361 @ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()),
3362 @ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and
3363 @ref basic_json::is_structured() rely on it.
3364 
3365 @note There are three enumeration entries (number_integer, number_unsigned, and
3366 number_float), because the library distinguishes these three types for numbers:
3367 @ref basic_json::number_unsigned_t is used for unsigned integers,
3368 @ref basic_json::number_integer_t is used for signed integers, and
3369 @ref basic_json::number_float_t is used for floating-point numbers or to
3370 approximate integers which do not fit in the limits of their respective type.
3371 
3372 @sa @ref basic_json::basic_json(const value_t value_type) -- create a JSON
3373 value with the default value for a given type
3374 
3375 @since version 1.0.0
3376 */
3377 enum class value_t : std::uint8_t
3378 {
3379  null, ///< null value
3380  object, ///< object (unordered set of name/value pairs)
3381  array, ///< array (ordered collection of values)
3382  string, ///< string value
3383  boolean, ///< boolean value
3384  number_integer, ///< number value (signed integer)
3385  number_unsigned, ///< number value (unsigned integer)
3386  number_float, ///< number value (floating-point)
3387  binary, ///< binary array (ordered collection of bytes)
3388  discarded ///< discarded by the parser callback function
3389 };
3390 
3391 /*!
3392 @brief comparison operator for JSON types
3393 
3394 Returns an ordering that is similar to Python:
3395 - order: null < boolean < number < object < array < string < binary
3396 - furthermore, each type is not smaller than itself
3397 - discarded values are not comparable
3398 - binary is represented as a b"" string in python and directly comparable to a
3399  string; however, making a binary array directly comparable with a string would
3400  be surprising behavior in a JSON file.
3401 
3402 @since version 1.0.0
3403 */
3404 inline bool operator<(const value_t lhs, const value_t rhs) noexcept
3405 {
3406  static constexpr std::array<std::uint8_t, 9> order = {{
3407  0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */,
3408  1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */,
3409  6 /* binary */
3410  }
3411  };
3412 
3413  const auto l_index = static_cast<std::size_t>(lhs);
3414  const auto r_index = static_cast<std::size_t>(rhs);
3415  return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index];
3416 }
3417 } // namespace detail
3418 } // namespace nlohmann
3419 
3420 
3421 namespace nlohmann
3422 {
3423 namespace detail
3424 {
3425 template<typename BasicJsonType>
3426 void from_json(const BasicJsonType& j, typename std::nullptr_t& n)
3427 {
3428  if (JSON_HEDLEY_UNLIKELY(!j.is_null()))
3429  {
3430  JSON_THROW(type_error::create(302, "type must be null, but is " + std::string(j.type_name())));
3431  }
3432  n = nullptr;
3433 }
3434 
3435 // overloads for basic_json template parameters
3436 template < typename BasicJsonType, typename ArithmeticType,
3437  enable_if_t < std::is_arithmetic<ArithmeticType>::value&&
3438  !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
3439  int > = 0 >
3440 void get_arithmetic_value(const BasicJsonType& j, ArithmeticType& val)
3441 {
3442  switch (static_cast<value_t>(j))
3443  {
3445  {
3446  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3447  break;
3448  }
3450  {
3451  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3452  break;
3453  }
3454  case value_t::number_float:
3455  {
3456  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3457  break;
3458  }
3459 
3460  default:
3461  JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
3462  }
3463 }
3464 
3465 template<typename BasicJsonType>
3466 void from_json(const BasicJsonType& j, typename BasicJsonType::boolean_t& b)
3467 {
3468  if (JSON_HEDLEY_UNLIKELY(!j.is_boolean()))
3469  {
3470  JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(j.type_name())));
3471  }
3472  b = *j.template get_ptr<const typename BasicJsonType::boolean_t*>();
3473 }
3474 
3475 template<typename BasicJsonType>
3476 void from_json(const BasicJsonType& j, typename BasicJsonType::string_t& s)
3477 {
3478  if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3479  {
3480  JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
3481  }
3482  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3483 }
3484 
3485 template <
3486  typename BasicJsonType, typename ConstructibleStringType,
3487  enable_if_t <
3488  is_constructible_string_type<BasicJsonType, ConstructibleStringType>::value&&
3489  !std::is_same<typename BasicJsonType::string_t,
3490  ConstructibleStringType>::value,
3491  int > = 0 >
3492 void from_json(const BasicJsonType& j, ConstructibleStringType& s)
3493 {
3494  if (JSON_HEDLEY_UNLIKELY(!j.is_string()))
3495  {
3496  JSON_THROW(type_error::create(302, "type must be string, but is " + std::string(j.type_name())));
3497  }
3498 
3499  s = *j.template get_ptr<const typename BasicJsonType::string_t*>();
3500 }
3501 
3502 template<typename BasicJsonType>
3503 void from_json(const BasicJsonType& j, typename BasicJsonType::number_float_t& val)
3504 {
3505  get_arithmetic_value(j, val);
3506 }
3507 
3508 template<typename BasicJsonType>
3509 void from_json(const BasicJsonType& j, typename BasicJsonType::number_unsigned_t& val)
3510 {
3511  get_arithmetic_value(j, val);
3512 }
3513 
3514 template<typename BasicJsonType>
3515 void from_json(const BasicJsonType& j, typename BasicJsonType::number_integer_t& val)
3516 {
3517  get_arithmetic_value(j, val);
3518 }
3519 
3520 template<typename BasicJsonType, typename EnumType,
3521  enable_if_t<std::is_enum<EnumType>::value, int> = 0>
3522 void from_json(const BasicJsonType& j, EnumType& e)
3523 {
3524  typename std::underlying_type<EnumType>::type val;
3525  get_arithmetic_value(j, val);
3526  e = static_cast<EnumType>(val);
3527 }
3528 
3529 // forward_list doesn't have an insert method
3530 template<typename BasicJsonType, typename T, typename Allocator,
3531  enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
3532 void from_json(const BasicJsonType& j, std::forward_list<T, Allocator>& l)
3533 {
3534  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3535  {
3536  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3537  }
3538  l.clear();
3539  std::transform(j.rbegin(), j.rend(),
3540  std::front_inserter(l), [](const BasicJsonType & i)
3541  {
3542  return i.template get<T>();
3543  });
3544 }
3545 
3546 // valarray doesn't have an insert method
3547 template<typename BasicJsonType, typename T,
3548  enable_if_t<is_getable<BasicJsonType, T>::value, int> = 0>
3549 void from_json(const BasicJsonType& j, std::valarray<T>& l)
3550 {
3551  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3552  {
3553  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3554  }
3555  l.resize(j.size());
3556  std::transform(j.begin(), j.end(), std::begin(l),
3557  [](const BasicJsonType & elem)
3558  {
3559  return elem.template get<T>();
3560  });
3561 }
3562 
3563 template<typename BasicJsonType, typename T, std::size_t N>
3564 auto from_json(const BasicJsonType& j, T (&arr)[N])
3565 -> decltype(j.template get<T>(), void())
3566 {
3567  for (std::size_t i = 0; i < N; ++i)
3568  {
3569  arr[i] = j.at(i).template get<T>();
3570  }
3571 }
3572 
3573 template<typename BasicJsonType>
3574 void from_json_array_impl(const BasicJsonType& j, typename BasicJsonType::array_t& arr, priority_tag<3> /*unused*/)
3575 {
3576  arr = *j.template get_ptr<const typename BasicJsonType::array_t*>();
3577 }
3578 
3579 template<typename BasicJsonType, typename T, std::size_t N>
3580 auto from_json_array_impl(const BasicJsonType& j, std::array<T, N>& arr,
3581  priority_tag<2> /*unused*/)
3582 -> decltype(j.template get<T>(), void())
3583 {
3584  for (std::size_t i = 0; i < N; ++i)
3585  {
3586  arr[i] = j.at(i).template get<T>();
3587  }
3588 }
3589 
3590 template<typename BasicJsonType, typename ConstructibleArrayType>
3591 auto from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr, priority_tag<1> /*unused*/)
3592 -> decltype(
3593  arr.reserve(std::declval<typename ConstructibleArrayType::size_type>()),
3594  j.template get<typename ConstructibleArrayType::value_type>(),
3595  void())
3596 {
3597  using std::end;
3598 
3599  ConstructibleArrayType ret;
3600  ret.reserve(j.size());
3601  std::transform(j.begin(), j.end(),
3602  std::inserter(ret, end(ret)), [](const BasicJsonType & i)
3603  {
3604  // get<BasicJsonType>() returns *this, this won't call a from_json
3605  // method when value_type is BasicJsonType
3606  return i.template get<typename ConstructibleArrayType::value_type>();
3607  });
3608  arr = std::move(ret);
3609 }
3610 
3611 template<typename BasicJsonType, typename ConstructibleArrayType>
3612 void from_json_array_impl(const BasicJsonType& j, ConstructibleArrayType& arr,
3613  priority_tag<0> /*unused*/)
3614 {
3615  using std::end;
3616 
3617  ConstructibleArrayType ret;
3618  std::transform(
3619  j.begin(), j.end(), std::inserter(ret, end(ret)),
3620  [](const BasicJsonType & i)
3621  {
3622  // get<BasicJsonType>() returns *this, this won't call a from_json
3623  // method when value_type is BasicJsonType
3624  return i.template get<typename ConstructibleArrayType::value_type>();
3625  });
3626  arr = std::move(ret);
3627 }
3628 
3629 template < typename BasicJsonType, typename ConstructibleArrayType,
3630  enable_if_t <
3631  is_constructible_array_type<BasicJsonType, ConstructibleArrayType>::value&&
3632  !is_constructible_object_type<BasicJsonType, ConstructibleArrayType>::value&&
3633  !is_constructible_string_type<BasicJsonType, ConstructibleArrayType>::value&&
3634  !std::is_same<ConstructibleArrayType, typename BasicJsonType::binary_t>::value&&
3635  !is_basic_json<ConstructibleArrayType>::value,
3636  int > = 0 >
3637 auto from_json(const BasicJsonType& j, ConstructibleArrayType& arr)
3638 -> decltype(from_json_array_impl(j, arr, priority_tag<3> {}),
3639 j.template get<typename ConstructibleArrayType::value_type>(),
3640 void())
3641 {
3642  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3643  {
3644  JSON_THROW(type_error::create(302, "type must be array, but is " +
3645  std::string(j.type_name())));
3646  }
3647 
3648  from_json_array_impl(j, arr, priority_tag<3> {});
3649 }
3650 
3651 template<typename BasicJsonType>
3652 void from_json(const BasicJsonType& j, typename BasicJsonType::binary_t& bin)
3653 {
3654  if (JSON_HEDLEY_UNLIKELY(!j.is_binary()))
3655  {
3656  JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(j.type_name())));
3657  }
3658 
3659  bin = *j.template get_ptr<const typename BasicJsonType::binary_t*>();
3660 }
3661 
3662 template<typename BasicJsonType, typename ConstructibleObjectType,
3663  enable_if_t<is_constructible_object_type<BasicJsonType, ConstructibleObjectType>::value, int> = 0>
3664 void from_json(const BasicJsonType& j, ConstructibleObjectType& obj)
3665 {
3666  if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
3667  {
3668  JSON_THROW(type_error::create(302, "type must be object, but is " + std::string(j.type_name())));
3669  }
3670 
3671  ConstructibleObjectType ret;
3672  auto inner_object = j.template get_ptr<const typename BasicJsonType::object_t*>();
3673  using value_type = typename ConstructibleObjectType::value_type;
3674  std::transform(
3675  inner_object->begin(), inner_object->end(),
3676  std::inserter(ret, ret.begin()),
3677  [](typename BasicJsonType::object_t::value_type const & p)
3678  {
3679  return value_type(p.first, p.second.template get<typename ConstructibleObjectType::mapped_type>());
3680  });
3681  obj = std::move(ret);
3682 }
3683 
3684 // overload for arithmetic types, not chosen for basic_json template arguments
3685 // (BooleanType, etc..); note: Is it really necessary to provide explicit
3686 // overloads for boolean_t etc. in case of a custom BooleanType which is not
3687 // an arithmetic type?
3688 template < typename BasicJsonType, typename ArithmeticType,
3689  enable_if_t <
3690  std::is_arithmetic<ArithmeticType>::value&&
3691  !std::is_same<ArithmeticType, typename BasicJsonType::number_unsigned_t>::value&&
3692  !std::is_same<ArithmeticType, typename BasicJsonType::number_integer_t>::value&&
3693  !std::is_same<ArithmeticType, typename BasicJsonType::number_float_t>::value&&
3694  !std::is_same<ArithmeticType, typename BasicJsonType::boolean_t>::value,
3695  int > = 0 >
3696 void from_json(const BasicJsonType& j, ArithmeticType& val)
3697 {
3698  switch (static_cast<value_t>(j))
3699  {
3701  {
3702  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_unsigned_t*>());
3703  break;
3704  }
3706  {
3707  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_integer_t*>());
3708  break;
3709  }
3710  case value_t::number_float:
3711  {
3712  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::number_float_t*>());
3713  break;
3714  }
3715  case value_t::boolean:
3716  {
3717  val = static_cast<ArithmeticType>(*j.template get_ptr<const typename BasicJsonType::boolean_t*>());
3718  break;
3719  }
3720 
3721  default:
3722  JSON_THROW(type_error::create(302, "type must be number, but is " + std::string(j.type_name())));
3723  }
3724 }
3725 
3726 template<typename BasicJsonType, typename A1, typename A2>
3727 void from_json(const BasicJsonType& j, std::pair<A1, A2>& p)
3728 {
3729  p = {j.at(0).template get<A1>(), j.at(1).template get<A2>()};
3730 }
3731 
3732 template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
3733 void from_json_tuple_impl(const BasicJsonType& j, Tuple& t, index_sequence<Idx...> /*unused*/)
3734 {
3735  t = std::make_tuple(j.at(Idx).template get<typename std::tuple_element<Idx, Tuple>::type>()...);
3736 }
3737 
3738 template<typename BasicJsonType, typename... Args>
3739 void from_json(const BasicJsonType& j, std::tuple<Args...>& t)
3740 {
3741  from_json_tuple_impl(j, t, index_sequence_for<Args...> {});
3742 }
3743 
3744 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
3745  typename = enable_if_t < !std::is_constructible <
3746  typename BasicJsonType::string_t, Key >::value >>
3747 void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
3748 {
3749  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3750  {
3751  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3752  }
3753  m.clear();
3754  for (const auto& p : j)
3755  {
3756  if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
3757  {
3758  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
3759  }
3760  m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
3761  }
3762 }
3763 
3764 template < typename BasicJsonType, typename Key, typename Value, typename Hash, typename KeyEqual, typename Allocator,
3765  typename = enable_if_t < !std::is_constructible <
3766  typename BasicJsonType::string_t, Key >::value >>
3767 void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
3768 {
3769  if (JSON_HEDLEY_UNLIKELY(!j.is_array()))
3770  {
3771  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(j.type_name())));
3772  }
3773  m.clear();
3774  for (const auto& p : j)
3775  {
3776  if (JSON_HEDLEY_UNLIKELY(!p.is_array()))
3777  {
3778  JSON_THROW(type_error::create(302, "type must be array, but is " + std::string(p.type_name())));
3779  }
3780  m.emplace(p.at(0).template get<Key>(), p.at(1).template get<Value>());
3781  }
3782 }
3783 
3785 {
3786  template<typename BasicJsonType, typename T>
3787  auto operator()(const BasicJsonType& j, T& val) const
3788  noexcept(noexcept(from_json(j, val)))
3789  -> decltype(from_json(j, val), void())
3790  {
3791  return from_json(j, val);
3792  }
3793 };
3794 } // namespace detail
3795 
3796 /// namespace to hold default `from_json` function
3797 /// to see why this is required:
3798 /// http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4381.html
3799 namespace
3800 {
3801 constexpr const auto& from_json = detail::static_const<detail::from_json_fn>::value;
3802 } // namespace
3803 } // namespace nlohmann
3804 
3805 // #include <nlohmann/detail/conversions/to_json.hpp>
3806 
3807 
3808 #include <algorithm> // copy
3809 #include <iterator> // begin, end
3810 #include <string> // string
3811 #include <tuple> // tuple, get
3812 #include <type_traits> // is_same, is_constructible, is_floating_point, is_enum, underlying_type
3813 #include <utility> // move, forward, declval, pair
3814 #include <valarray> // valarray
3815 #include <vector> // vector
3816 
3817 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
3818 
3819 
3820 #include <cstddef> // size_t
3821 #include <iterator> // input_iterator_tag
3822 #include <string> // string, to_string
3823 #include <tuple> // tuple_size, get, tuple_element
3824 
3825 // #include <nlohmann/detail/meta/type_traits.hpp>
3826 
3827 // #include <nlohmann/detail/value_t.hpp>
3828 
3829 
3830 namespace nlohmann
3831 {
3832 namespace detail
3833 {
3834 template<typename string_type>
3835 void int_to_string( string_type& target, std::size_t value )
3836 {
3837  // For ADL
3838  using std::to_string;
3839  target = to_string(value);
3840 }
3841 template<typename IteratorType> class iteration_proxy_value
3842 {
3843  public:
3844  using difference_type = std::ptrdiff_t;
3846  using pointer = value_type * ;
3847  using reference = value_type & ;
3848  using iterator_category = std::input_iterator_tag;
3849  using string_type = typename std::remove_cv< typename std::remove_reference<decltype( std::declval<IteratorType>().key() ) >::type >::type;
3850 
3851  private:
3852  /// the iterator
3853  IteratorType anchor;
3854  /// an index for arrays (used to create key names)
3855  std::size_t array_index = 0;
3856  /// last stringified array index
3857  mutable std::size_t array_index_last = 0;
3858  /// a string representation of the array index
3859  mutable string_type array_index_str = "0";
3860  /// an empty string (to return a reference for primitive values)
3861  const string_type empty_str = "";
3862 
3863  public:
3864  explicit iteration_proxy_value(IteratorType it) noexcept : anchor(it) {}
3865 
3866  /// dereference operator (needed for range-based for)
3868  {
3869  return *this;
3870  }
3871 
3872  /// increment operator (needed for range-based for)
3874  {
3875  ++anchor;
3876  ++array_index;
3877 
3878  return *this;
3879  }
3880 
3881  /// equality operator (needed for InputIterator)
3882  bool operator==(const iteration_proxy_value& o) const
3883  {
3884  return anchor == o.anchor;
3885  }
3886 
3887  /// inequality operator (needed for range-based for)
3888  bool operator!=(const iteration_proxy_value& o) const
3889  {
3890  return anchor != o.anchor;
3891  }
3892 
3893  /// return key of the iterator
3894  const string_type& key() const
3895  {
3896  JSON_ASSERT(anchor.m_object != nullptr);
3897 
3898  switch (anchor.m_object->type())
3899  {
3900  // use integer array index as key
3901  case value_t::array:
3902  {
3904  {
3905  int_to_string( array_index_str, array_index );
3907  }
3908  return array_index_str;
3909  }
3910 
3911  // use key from the object
3912  case value_t::object:
3913  return anchor.key();
3914 
3915  // use an empty key for all primitive types
3916  default:
3917  return empty_str;
3918  }
3919  }
3920 
3921  /// return value of the iterator
3922  typename IteratorType::reference value() const
3923  {
3924  return anchor.value();
3925  }
3926 };
3927 
3928 /// proxy class for the items() function
3929 template<typename IteratorType> class iteration_proxy
3930 {
3931  private:
3932  /// the container to iterate
3933  typename IteratorType::reference container;
3934 
3935  public:
3936  /// construct iteration proxy from a container
3937  explicit iteration_proxy(typename IteratorType::reference cont) noexcept
3938  : container(cont) {}
3939 
3940  /// return iterator begin (needed for range-based for)
3942  {
3944  }
3945 
3946  /// return iterator end (needed for range-based for)
3948  {
3950  }
3951 };
3952 // Structured Bindings Support
3953 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
3954 // And see https://github.com/nlohmann/json/pull/1391
3955 template<std::size_t N, typename IteratorType, enable_if_t<N == 0, int> = 0>
3956 auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.key())
3957 {
3958  return i.key();
3959 }
3960 // Structured Bindings Support
3961 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
3962 // And see https://github.com/nlohmann/json/pull/1391
3963 template<std::size_t N, typename IteratorType, enable_if_t<N == 1, int> = 0>
3964 auto get(const nlohmann::detail::iteration_proxy_value<IteratorType>& i) -> decltype(i.value())
3965 {
3966  return i.value();
3967 }
3968 } // namespace detail
3969 } // namespace nlohmann
3970 
3971 // The Addition to the STD Namespace is required to add
3972 // Structured Bindings Support to the iteration_proxy_value class
3973 // For further reference see https://blog.tartanllama.xyz/structured-bindings/
3974 // And see https://github.com/nlohmann/json/pull/1391
3975 namespace std
3976 {
3977 #if defined(__clang__)
3978  // Fix: https://github.com/nlohmann/json/issues/1401
3979  #pragma clang diagnostic push
3980  #pragma clang diagnostic ignored "-Wmismatched-tags"
3981 #endif
3982 template<typename IteratorType>
3983 class tuple_size<::nlohmann::detail::iteration_proxy_value<IteratorType>>
3984  : public std::integral_constant<std::size_t, 2> {};
3985 
3986 template<std::size_t N, typename IteratorType>
3987 class tuple_element<N, ::nlohmann::detail::iteration_proxy_value<IteratorType >>
3988 {
3989  public:
3990  using type = decltype(
3991  get<N>(std::declval <
3993 };
3994 #if defined(__clang__)
3995  #pragma clang diagnostic pop
3996 #endif
3997 } // namespace std
3998 
3999 // #include <nlohmann/detail/meta/cpp_future.hpp>
4000 
4001 // #include <nlohmann/detail/meta/type_traits.hpp>
4002 
4003 // #include <nlohmann/detail/value_t.hpp>
4004 
4005 
4006 namespace nlohmann
4007 {
4008 namespace detail
4009 {
4010 //////////////////
4011 // constructors //
4012 //////////////////
4013 
4014 template<value_t> struct external_constructor;
4015 
4016 template<>
4018 {
4019  template<typename BasicJsonType>
4020  static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
4021  {
4022  j.m_type = value_t::boolean;
4023  j.m_value = b;
4024  j.assert_invariant();
4025  }
4026 };
4027 
4028 template<>
4030 {
4031  template<typename BasicJsonType>
4032  static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
4033  {
4034  j.m_type = value_t::string;
4035  j.m_value = s;
4036  j.assert_invariant();
4037  }
4038 
4039  template<typename BasicJsonType>
4040  static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
4041  {
4042  j.m_type = value_t::string;
4043  j.m_value = std::move(s);
4044  j.assert_invariant();
4045  }
4046 
4047  template < typename BasicJsonType, typename CompatibleStringType,
4048  enable_if_t < !std::is_same<CompatibleStringType, typename BasicJsonType::string_t>::value,
4049  int > = 0 >
4050  static void construct(BasicJsonType& j, const CompatibleStringType& str)
4051  {
4052  j.m_type = value_t::string;
4053  j.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
4054  j.assert_invariant();
4055  }
4056 };
4057 
4058 template<>
4060 {
4061  template<typename BasicJsonType>
4062  static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
4063  {
4064  j.m_type = value_t::binary;
4065  typename BasicJsonType::binary_t value{b};
4066  j.m_value = value;
4067  j.assert_invariant();
4068  }
4069 
4070  template<typename BasicJsonType>
4071  static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
4072  {
4073  j.m_type = value_t::binary;
4074  typename BasicJsonType::binary_t value{std::move(b)};
4075  j.m_value = value;
4076  j.assert_invariant();
4077  }
4078 };
4079 
4080 template<>
4082 {
4083  template<typename BasicJsonType>
4084  static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
4085  {
4086  j.m_type = value_t::number_float;
4087  j.m_value = val;
4088  j.assert_invariant();
4089  }
4090 };
4091 
4092 template<>
4094 {
4095  template<typename BasicJsonType>
4096  static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
4097  {
4098  j.m_type = value_t::number_unsigned;
4099  j.m_value = val;
4100  j.assert_invariant();
4101  }
4102 };
4103 
4104 template<>
4106 {
4107  template<typename BasicJsonType>
4108  static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
4109  {
4110  j.m_type = value_t::number_integer;
4111  j.m_value = val;
4112  j.assert_invariant();
4113  }
4114 };
4115 
4116 template<>
4118 {
4119  template<typename BasicJsonType>
4120  static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
4121  {
4122  j.m_type = value_t::array;
4123  j.m_value = arr;
4124  j.assert_invariant();
4125  }
4126 
4127  template<typename BasicJsonType>
4128  static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
4129  {
4130  j.m_type = value_t::array;
4131  j.m_value = std::move(arr);
4132  j.assert_invariant();
4133  }
4134 
4135  template < typename BasicJsonType, typename CompatibleArrayType,
4136  enable_if_t < !std::is_same<CompatibleArrayType, typename BasicJsonType::array_t>::value,
4137  int > = 0 >
4138  static void construct(BasicJsonType& j, const CompatibleArrayType& arr)
4139  {
4140  using std::begin;
4141  using std::end;
4142  j.m_type = value_t::array;
4143  j.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
4144  j.assert_invariant();
4145  }
4146 
4147  template<typename BasicJsonType>
4148  static void construct(BasicJsonType& j, const std::vector<bool>& arr)
4149  {
4150  j.m_type = value_t::array;
4151  j.m_value = value_t::array;
4152  j.m_value.array->reserve(arr.size());
4153  for (const bool x : arr)
4154  {
4155  j.m_value.array->push_back(x);
4156  }
4157  j.assert_invariant();
4158  }
4159 
4160  template<typename BasicJsonType, typename T,
4161  enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
4162  static void construct(BasicJsonType& j, const std::valarray<T>& arr)
4163  {
4164  j.m_type = value_t::array;
4165  j.m_value = value_t::array;
4166  j.m_value.array->resize(arr.size());
4167  if (arr.size() > 0)
4168  {
4169  std::copy(std::begin(arr), std::end(arr), j.m_value.array->begin());
4170  }
4171  j.assert_invariant();
4172  }
4173 };
4174 
4175 template<>
4177 {
4178  template<typename BasicJsonType>
4179  static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
4180  {
4181  j.m_type = value_t::object;
4182  j.m_value = obj;
4183  j.assert_invariant();
4184  }
4185 
4186  template<typename BasicJsonType>
4187  static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
4188  {
4189  j.m_type = value_t::object;
4190  j.m_value = std::move(obj);
4191  j.assert_invariant();
4192  }
4193 
4194  template < typename BasicJsonType, typename CompatibleObjectType,
4195  enable_if_t < !std::is_same<CompatibleObjectType, typename BasicJsonType::object_t>::value, int > = 0 >
4196  static void construct(BasicJsonType& j, const CompatibleObjectType& obj)
4197  {
4198  using std::begin;
4199  using std::end;
4200 
4201  j.m_type = value_t::object;
4202  j.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
4203  j.assert_invariant();
4204  }
4205 };
4206 
4207 /////////////
4208 // to_json //
4209 /////////////
4210 
4211 template<typename BasicJsonType, typename T,
4212  enable_if_t<std::is_same<T, typename BasicJsonType::boolean_t>::value, int> = 0>
4213 void to_json(BasicJsonType& j, T b) noexcept
4214 {
4216 }
4217 
4218 template<typename BasicJsonType, typename CompatibleString,
4219  enable_if_t<std::is_constructible<typename BasicJsonType::string_t, CompatibleString>::value, int> = 0>
4220 void to_json(BasicJsonType& j, const CompatibleString& s)
4221 {
4222  external_constructor<value_t::string>::construct(j, s);
4223 }
4224 
4225 template<typename BasicJsonType>
4226 void to_json(BasicJsonType& j, typename BasicJsonType::string_t&& s)
4227 {
4228  external_constructor<value_t::string>::construct(j, std::move(s));
4229 }
4230 
4231 template<typename BasicJsonType, typename FloatType,
4232  enable_if_t<std::is_floating_point<FloatType>::value, int> = 0>
4233 void to_json(BasicJsonType& j, FloatType val) noexcept
4234 {
4235  external_constructor<value_t::number_float>::construct(j, static_cast<typename BasicJsonType::number_float_t>(val));
4236 }
4237 
4238 template<typename BasicJsonType, typename CompatibleNumberUnsignedType,
4239  enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_unsigned_t, CompatibleNumberUnsignedType>::value, int> = 0>
4240 void to_json(BasicJsonType& j, CompatibleNumberUnsignedType val) noexcept
4241 {
4242  external_constructor<value_t::number_unsigned>::construct(j, static_cast<typename BasicJsonType::number_unsigned_t>(val));
4243 }
4244 
4245 template<typename BasicJsonType, typename CompatibleNumberIntegerType,
4246  enable_if_t<is_compatible_integer_type<typename BasicJsonType::number_integer_t, CompatibleNumberIntegerType>::value, int> = 0>
4247 void to_json(BasicJsonType& j, CompatibleNumberIntegerType val) noexcept
4248 {
4249  external_constructor<value_t::number_integer>::construct(j, static_cast<typename BasicJsonType::number_integer_t>(val));
4250 }
4251 
4252 template<typename BasicJsonType, typename EnumType,
4253  enable_if_t<std::is_enum<EnumType>::value, int> = 0>
4254 void to_json(BasicJsonType& j, EnumType e) noexcept
4255 {
4256  using underlying_type = typename std::underlying_type<EnumType>::type;
4257  external_constructor<value_t::number_integer>::construct(j, static_cast<underlying_type>(e));
4258 }
4259 
4260 template<typename BasicJsonType>
4261 void to_json(BasicJsonType& j, const std::vector<bool>& e)
4262 {
4263  external_constructor<value_t::array>::construct(j, e);
4264 }
4265 
4266 template < typename BasicJsonType, typename CompatibleArrayType,
4267  enable_if_t < is_compatible_array_type<BasicJsonType,
4268  CompatibleArrayType>::value&&
4269  !is_compatible_object_type<BasicJsonType, CompatibleArrayType>::value&&
4270  !is_compatible_string_type<BasicJsonType, CompatibleArrayType>::value&&
4271  !std::is_same<typename BasicJsonType::binary_t, CompatibleArrayType>::value&&
4272  !is_basic_json<CompatibleArrayType>::value,
4273  int > = 0 >
4274 void to_json(BasicJsonType& j, const CompatibleArrayType& arr)
4275 {
4276  external_constructor<value_t::array>::construct(j, arr);
4277 }
4278 
4279 template<typename BasicJsonType>
4280 void to_json(BasicJsonType& j, const typename BasicJsonType::binary_t& bin)
4281 {
4282  external_constructor<value_t::binary>::construct(j, bin);
4283 }
4284 
4285 template<typename BasicJsonType, typename T,
4286  enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
4287 void to_json(BasicJsonType& j, const std::valarray<T>& arr)
4288 {
4289  external_constructor<value_t::array>::construct(j, std::move(arr));
4290 }
4291 
4292 template<typename BasicJsonType>
4293 void to_json(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
4294 {
4295  external_constructor<value_t::array>::construct(j, std::move(arr));
4296 }
4297 
4298 template < typename BasicJsonType, typename CompatibleObjectType,
4299  enable_if_t < is_compatible_object_type<BasicJsonType, CompatibleObjectType>::value&& !is_basic_json<CompatibleObjectType>::value, int > = 0 >
4300 void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
4301 {
4302  external_constructor<value_t::object>::construct(j, obj);
4303 }
4304 
4305 template<typename BasicJsonType>
4306 void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
4307 {
4308  external_constructor<value_t::object>::construct(j, std::move(obj));
4309 }
4310 
4311 template <
4312  typename BasicJsonType, typename T, std::size_t N,
4313  enable_if_t < !std::is_constructible<typename BasicJsonType::string_t,
4314  const T(&)[N]>::value,
4315  int > = 0 >
4316 void to_json(BasicJsonType& j, const T(&arr)[N])
4317 {
4318  external_constructor<value_t::array>::construct(j, arr);
4319 }
4320 
4321 template < typename BasicJsonType, typename T1, typename T2, enable_if_t < std::is_constructible<BasicJsonType, T1>::value&& std::is_constructible<BasicJsonType, T2>::value, int > = 0 >
4322 void to_json(BasicJsonType& j, const std::pair<T1, T2>& p)
4323 {
4324  j = { p.first, p.second };
4325 }
4326 
4327 // for https://github.com/nlohmann/json/pull/1134
4328 template<typename BasicJsonType, typename T,
4329  enable_if_t<std::is_same<T, iteration_proxy_value<typename BasicJsonType::iterator>>::value, int> = 0>
4330 void to_json(BasicJsonType& j, const T& b)
4331 {
4332  j = { {b.key(), b.value()} };
4333 }
4334 
4335 template<typename BasicJsonType, typename Tuple, std::size_t... Idx>
4336 void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<Idx...> /*unused*/)
4337 {
4338  j = { std::get<Idx>(t)... };
4339 }
4340 
4341 template<typename BasicJsonType, typename T, enable_if_t<is_constructible_tuple<BasicJsonType, T>::value, int > = 0>
4342 void to_json(BasicJsonType& j, const T& t)
4343 {
4344  to_json_tuple_impl(j, t, make_index_sequence<std::tuple_size<T>::value> {});
4345 }
4346 
4348 {
4349  template<typename BasicJsonType, typename T>
4350  auto operator()(BasicJsonType& j, T&& val) const noexcept(noexcept(to_json(j, std::forward<T>(val))))
4351  -> decltype(to_json(j, std::forward<T>(val)), void())
4352  {
4353  return to_json(j, std::forward<T>(val));
4354  }
4355 };
4356 } // namespace detail
4357 
4358 /// namespace to hold default `to_json` function
4359 namespace
4360 {
4361 constexpr const auto& to_json = detail::static_const<detail::to_json_fn>::value;
4362 } // namespace
4363 } // namespace nlohmann
4364 
4365 
4366 namespace nlohmann
4367 {
4368 
4369 template<typename, typename>
4371 {
4372  /*!
4373  @brief convert a JSON value to any value type
4374 
4375  This function is usually called by the `get()` function of the
4376  @ref basic_json class (either explicit or via conversion operators).
4377 
4378  @param[in] j JSON value to read from
4379  @param[in,out] val value to write to
4380  */
4381  template<typename BasicJsonType, typename ValueType>
4382  static auto from_json(BasicJsonType&& j, ValueType& val) noexcept(
4383  noexcept(::nlohmann::from_json(std::forward<BasicJsonType>(j), val)))
4384  -> decltype(::nlohmann::from_json(std::forward<BasicJsonType>(j), val), void())
4385  {
4386  ::nlohmann::from_json(std::forward<BasicJsonType>(j), val);
4387  }
4388 
4389  /*!
4390  @brief convert any value type to a JSON value
4391 
4392  This function is usually called by the constructors of the @ref basic_json
4393  class.
4394 
4395  @param[in,out] j JSON value to write to
4396  @param[in] val value to read from
4397  */
4398  template<typename BasicJsonType, typename ValueType>
4399  static auto to_json(BasicJsonType& j, ValueType&& val) noexcept(
4400  noexcept(::nlohmann::to_json(j, std::forward<ValueType>(val))))
4401  -> decltype(::nlohmann::to_json(j, std::forward<ValueType>(val)), void())
4402  {
4403  ::nlohmann::to_json(j, std::forward<ValueType>(val));
4404  }
4405 };
4406 
4407 } // namespace nlohmann
4408 
4409 // #include <nlohmann/byte_container_with_subtype.hpp>
4410 
4411 
4412 #include <cstdint> // uint8_t
4413 #include <tuple> // tie
4414 #include <utility> // move
4415 
4416 namespace nlohmann
4417 {
4418 
4419 /*!
4420 @brief an internal type for a backed binary type
4421 
4422 This type extends the template parameter @a BinaryType provided to `basic_json`
4423 with a subtype used by BSON and MessagePack. This type exists so that the user
4424 does not have to specify a type themselves with a specific naming scheme in
4425 order to override the binary type.
4426 
4427 @tparam BinaryType container to store bytes (`std::vector<std::uint8_t>` by
4428  default)
4429 
4430 @since version 3.8.0
4431 */
4432 template<typename BinaryType>
4433 class byte_container_with_subtype : public BinaryType
4434 {
4435  public:
4436  /// the type of the underlying container
4437  using container_type = BinaryType;
4438 
4439  byte_container_with_subtype() noexcept(noexcept(container_type()))
4440  : container_type()
4441  {}
4442 
4443  byte_container_with_subtype(const container_type& b) noexcept(noexcept(container_type(b)))
4444  : container_type(b)
4445  {}
4446 
4447  byte_container_with_subtype(container_type&& b) noexcept(noexcept(container_type(std::move(b))))
4448  : container_type(std::move(b))
4449  {}
4450 
4451  byte_container_with_subtype(const container_type& b, std::uint8_t subtype) noexcept(noexcept(container_type(b)))
4452  : container_type(b)
4453  , m_subtype(subtype)
4454  , m_has_subtype(true)
4455  {}
4456 
4457  byte_container_with_subtype(container_type&& b, std::uint8_t subtype) noexcept(noexcept(container_type(std::move(b))))
4458  : container_type(std::move(b))
4459  , m_subtype(subtype)
4460  , m_has_subtype(true)
4461  {}
4462 
4463  bool operator==(const byte_container_with_subtype& rhs) const
4464  {
4465  return std::tie(static_cast<const BinaryType&>(*this), m_subtype, m_has_subtype) ==
4466  std::tie(static_cast<const BinaryType&>(rhs), rhs.m_subtype, rhs.m_has_subtype);
4467  }
4468 
4469  bool operator!=(const byte_container_with_subtype& rhs) const
4470  {
4471  return !(rhs == *this);
4472  }
4473 
4474  /*!
4475  @brief sets the binary subtype
4476 
4477  Sets the binary subtype of the value, also flags a binary JSON value as
4478  having a subtype, which has implications for serialization.
4479 
4480  @complexity Constant.
4481 
4482  @exceptionsafety No-throw guarantee: this member function never throws
4483  exceptions.
4484 
4485  @sa @ref subtype() -- return the binary subtype
4486  @sa @ref clear_subtype() -- clears the binary subtype
4487  @sa @ref has_subtype() -- returns whether or not the binary value has a
4488  subtype
4489 
4490  @since version 3.8.0
4491  */
4492  void set_subtype(std::uint8_t subtype) noexcept
4493  {
4494  m_subtype = subtype;
4495  m_has_subtype = true;
4496  }
4497 
4498  /*!
4499  @brief return the binary subtype
4500 
4501  Returns the numerical subtype of the value if it has a subtype. If it does
4502  not have a subtype, this function will return size_t(-1) as a sentinel
4503  value.
4504 
4505  @return the numerical subtype of the binary value
4506 
4507  @complexity Constant.
4508 
4509  @exceptionsafety No-throw guarantee: this member function never throws
4510  exceptions.
4511 
4512  @sa @ref set_subtype() -- sets the binary subtype
4513  @sa @ref clear_subtype() -- clears the binary subtype
4514  @sa @ref has_subtype() -- returns whether or not the binary value has a
4515  subtype
4516 
4517  @since version 3.8.0
4518  */
4519  constexpr std::uint8_t subtype() const noexcept
4520  {
4521  return m_subtype;
4522  }
4523 
4524  /*!
4525  @brief return whether the value has a subtype
4526 
4527  @return whether the value has a subtype
4528 
4529  @complexity Constant.
4530 
4531  @exceptionsafety No-throw guarantee: this member function never throws
4532  exceptions.
4533 
4534  @sa @ref subtype() -- return the binary subtype
4535  @sa @ref set_subtype() -- sets the binary subtype
4536  @sa @ref clear_subtype() -- clears the binary subtype
4537 
4538  @since version 3.8.0
4539  */
4540  constexpr bool has_subtype() const noexcept
4541  {
4542  return m_has_subtype;
4543  }
4544 
4545  /*!
4546  @brief clears the binary subtype
4547 
4548  Clears the binary subtype and flags the value as not having a subtype, which
4549  has implications for serialization; for instance MessagePack will prefer the
4550  bin family over the ext family.
4551 
4552  @complexity Constant.
4553 
4554  @exceptionsafety No-throw guarantee: this member function never throws
4555  exceptions.
4556 
4557  @sa @ref subtype() -- return the binary subtype
4558  @sa @ref set_subtype() -- sets the binary subtype
4559  @sa @ref has_subtype() -- returns whether or not the binary value has a
4560  subtype
4561 
4562  @since version 3.8.0
4563  */
4564  void clear_subtype() noexcept
4565  {
4566  m_subtype = 0;
4567  m_has_subtype = false;
4568  }
4569 
4570  private:
4571  std::uint8_t m_subtype = 0;
4572  bool m_has_subtype = false;
4573 };
4574 
4575 } // namespace nlohmann
4576 
4577 // #include <nlohmann/detail/conversions/from_json.hpp>
4578 
4579 // #include <nlohmann/detail/conversions/to_json.hpp>
4580 
4581 // #include <nlohmann/detail/exceptions.hpp>
4582 
4583 // #include <nlohmann/detail/hash.hpp>
4584 
4585 
4586 #include <cstddef> // size_t, uint8_t
4587 #include <functional> // hash
4588 
4589 namespace nlohmann
4590 {
4591 namespace detail
4592 {
4593 
4594 // boost::hash_combine
4595 inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
4596 {
4597  seed ^= h + 0x9e3779b9 + (seed << 6U) + (seed >> 2U);
4598  return seed;
4599 }
4600 
4601 /*!
4602 @brief hash a JSON value
4603 
4604 The hash function tries to rely on std::hash where possible. Furthermore, the
4605 type of the JSON value is taken into account to have different hash values for
4606 null, 0, 0U, and false, etc.
4607 
4608 @tparam BasicJsonType basic_json specialization
4609 @param j JSON value to hash
4610 @return hash value of j
4611 */
4612 template<typename BasicJsonType>
4613 std::size_t hash(const BasicJsonType& j)
4614 {
4615  using string_t = typename BasicJsonType::string_t;
4616  using number_integer_t = typename BasicJsonType::number_integer_t;
4617  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
4618  using number_float_t = typename BasicJsonType::number_float_t;
4619 
4620  const auto type = static_cast<std::size_t>(j.type());
4621  switch (j.type())
4622  {
4623  case BasicJsonType::value_t::null:
4624  case BasicJsonType::value_t::discarded:
4625  {
4626  return combine(type, 0);
4627  }
4628 
4629  case BasicJsonType::value_t::object:
4630  {
4631  auto seed = combine(type, j.size());
4632  for (const auto& element : j.items())
4633  {
4634  const auto h = std::hash<string_t> {}(element.key());
4635  seed = combine(seed, h);
4636  seed = combine(seed, hash(element.value()));
4637  }
4638  return seed;
4639  }
4640 
4641  case BasicJsonType::value_t::array:
4642  {
4643  auto seed = combine(type, j.size());
4644  for (const auto& element : j)
4645  {
4646  seed = combine(seed, hash(element));
4647  }
4648  return seed;
4649  }
4650 
4651  case BasicJsonType::value_t::string:
4652  {
4653  const auto h = std::hash<string_t> {}(j.template get_ref<const string_t&>());
4654  return combine(type, h);
4655  }
4656 
4657  case BasicJsonType::value_t::boolean:
4658  {
4659  const auto h = std::hash<bool> {}(j.template get<bool>());
4660  return combine(type, h);
4661  }
4662 
4663  case BasicJsonType::value_t::number_integer:
4664  {
4665  const auto h = std::hash<number_integer_t> {}(j.template get<number_integer_t>());
4666  return combine(type, h);
4667  }
4668 
4670  {
4671  const auto h = std::hash<number_unsigned_t> {}(j.template get<number_unsigned_t>());
4672  return combine(type, h);
4673  }
4674 
4676  {
4677  const auto h = std::hash<number_float_t> {}(j.template get<number_float_t>());
4678  return combine(type, h);
4679  }
4680 
4682  {
4683  auto seed = combine(type, j.get_binary().size());
4684  const auto h = std::hash<bool> {}(j.get_binary().has_subtype());
4685  seed = combine(seed, h);
4686  seed = combine(seed, j.get_binary().subtype());
4687  for (const auto byte : j.get_binary())
4688  {
4689  seed = combine(seed, std::hash<std::uint8_t> {}(byte));
4690  }
4691  return seed;
4692  }
4693 
4694  default: // LCOV_EXCL_LINE
4695  JSON_ASSERT(false); // LCOV_EXCL_LINE
4696  }
4697 }
4698 
4699 } // namespace detail
4700 } // namespace nlohmann
4701 
4702 // #include <nlohmann/detail/input/binary_reader.hpp>
4703 
4704 
4705 #include <algorithm> // generate_n
4706 #include <array> // array
4707 #include <cmath> // ldexp
4708 #include <cstddef> // size_t
4709 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
4710 #include <cstdio> // snprintf
4711 #include <cstring> // memcpy
4712 #include <iterator> // back_inserter
4713 #include <limits> // numeric_limits
4714 #include <string> // char_traits, string
4715 #include <utility> // make_pair, move
4716 
4717 // #include <nlohmann/detail/exceptions.hpp>
4718 
4719 // #include <nlohmann/detail/input/input_adapters.hpp>
4720 
4721 
4722 #include <array> // array
4723 #include <cstddef> // size_t
4724 #include <cstdio> //FILE *
4725 #include <cstring> // strlen
4726 #include <istream> // istream
4727 #include <iterator> // begin, end, iterator_traits, random_access_iterator_tag, distance, next
4728 #include <memory> // shared_ptr, make_shared, addressof
4729 #include <numeric> // accumulate
4730 #include <string> // string, char_traits
4731 #include <type_traits> // enable_if, is_base_of, is_pointer, is_integral, remove_pointer
4732 #include <utility> // pair, declval
4733 
4734 // #include <nlohmann/detail/iterators/iterator_traits.hpp>
4735 
4736 // #include <nlohmann/detail/macro_scope.hpp>
4737 
4738 
4739 namespace nlohmann
4740 {
4741 namespace detail
4742 {
4743 /// the supported input formats
4744 enum class input_format_t { json, cbor, msgpack, ubjson, bson };
4745 
4746 ////////////////////
4747 // input adapters //
4748 ////////////////////
4749 
4750 /*!
4751 Input adapter for stdio file access. This adapter read only 1 byte and do not use any
4752  buffer. This adapter is a very low level adapter.
4753 */
4755 {
4756  public:
4757  using char_type = char;
4758 
4759  JSON_HEDLEY_NON_NULL(2)
4760  explicit file_input_adapter(std::FILE* f) noexcept
4761  : m_file(f)
4762  {}
4763 
4764  // make class move-only
4765  file_input_adapter(const file_input_adapter&) = delete;
4767  file_input_adapter& operator=(const file_input_adapter&) = delete;
4768  file_input_adapter& operator=(file_input_adapter&&) = delete;
4769 
4770  std::char_traits<char>::int_type get_character() noexcept
4771  {
4772  return std::fgetc(m_file);
4773  }
4774 
4775  private:
4776  /// the file pointer to read from
4777  std::FILE* m_file;
4778 };
4779 
4780 
4781 /*!
4782 Input adapter for a (caching) istream. Ignores a UFT Byte Order Mark at
4783 beginning of input. Does not support changing the underlying std::streambuf
4784 in mid-input. Maintains underlying std::istream and std::streambuf to support
4785 subsequent use of standard std::istream operations to process any input
4786 characters following those used in parsing the JSON input. Clears the
4787 std::istream flags; any input errors (e.g., EOF) will be detected by the first
4788 subsequent call for input from the std::istream.
4789 */
4791 {
4792  public:
4793  using char_type = char;
4794 
4796  {
4797  // clear stream flags; we use underlying streambuf I/O, do not
4798  // maintain ifstream flags, except eof
4799  if (is != nullptr)
4800  {
4801  is->clear(is->rdstate() & std::ios::eofbit);
4802  }
4803  }
4804 
4805  explicit input_stream_adapter(std::istream& i)
4806  : is(&i), sb(i.rdbuf())
4807  {}
4808 
4809  // delete because of pointer members
4810  input_stream_adapter(const input_stream_adapter&) = delete;
4811  input_stream_adapter& operator=(input_stream_adapter&) = delete;
4812  input_stream_adapter& operator=(input_stream_adapter&& rhs) = delete;
4813 
4814  input_stream_adapter(input_stream_adapter&& rhs) noexcept : is(rhs.is), sb(rhs.sb)
4815  {
4816  rhs.is = nullptr;
4817  rhs.sb = nullptr;
4818  }
4819 
4820  // std::istream/std::streambuf use std::char_traits<char>::to_int_type, to
4821  // ensure that std::char_traits<char>::eof() and the character 0xFF do not
4822  // end up as the same value, eg. 0xFFFFFFFF.
4823  std::char_traits<char>::int_type get_character()
4824  {
4825  auto res = sb->sbumpc();
4826  // set eof manually, as we don't use the istream interface.
4827  if (JSON_HEDLEY_UNLIKELY(res == EOF))
4828  {
4829  is->clear(is->rdstate() | std::ios::eofbit);
4830  }
4831  return res;
4832  }
4833 
4834  private:
4835  /// the associated input stream
4836  std::istream* is = nullptr;
4837  std::streambuf* sb = nullptr;
4838 };
4839 
4840 // General-purpose iterator-based adapter. It might not be as fast as
4841 // theoretically possible for some containers, but it is extremely versatile.
4842 template<typename IteratorType>
4844 {
4845  public:
4846  using char_type = typename std::iterator_traits<IteratorType>::value_type;
4847 
4848  iterator_input_adapter(IteratorType first, IteratorType last)
4849  : current(std::move(first)), end(std::move(last)) {}
4850 
4851  typename std::char_traits<char_type>::int_type get_character()
4852  {
4853  if (JSON_HEDLEY_LIKELY(current != end))
4854  {
4855  auto result = std::char_traits<char_type>::to_int_type(*current);
4856  std::advance(current, 1);
4857  return result;
4858  }
4859  else
4860  {
4861  return std::char_traits<char_type>::eof();
4862  }
4863  }
4864 
4865  private:
4866  IteratorType current;
4867  IteratorType end;
4868 
4869  template<typename BaseInputAdapter, size_t T>
4870  friend struct wide_string_input_helper;
4871 
4872  bool empty() const
4873  {
4874  return current == end;
4875  }
4876 
4877 };
4878 
4879 
4880 template<typename BaseInputAdapter, size_t T>
4882 
4883 template<typename BaseInputAdapter>
4884 struct wide_string_input_helper<BaseInputAdapter, 4>
4885 {
4886  // UTF-32
4887  static void fill_buffer(BaseInputAdapter& input,
4888  std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
4889  size_t& utf8_bytes_index,
4890  size_t& utf8_bytes_filled)
4891  {
4892  utf8_bytes_index = 0;
4893 
4894  if (JSON_HEDLEY_UNLIKELY(input.empty()))
4895  {
4896  utf8_bytes[0] = std::char_traits<char>::eof();
4897  utf8_bytes_filled = 1;
4898  }
4899  else
4900  {
4901  // get the current character
4902  const auto wc = input.get_character();
4903 
4904  // UTF-32 to UTF-8 encoding
4905  if (wc < 0x80)
4906  {
4907  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4908  utf8_bytes_filled = 1;
4909  }
4910  else if (wc <= 0x7FF)
4911  {
4912  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u) & 0x1Fu));
4913  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
4914  utf8_bytes_filled = 2;
4915  }
4916  else if (wc <= 0xFFFF)
4917  {
4918  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u) & 0x0Fu));
4919  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
4920  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
4921  utf8_bytes_filled = 3;
4922  }
4923  else if (wc <= 0x10FFFF)
4924  {
4925  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | ((static_cast<unsigned int>(wc) >> 18u) & 0x07u));
4926  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 12u) & 0x3Fu));
4927  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
4928  utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
4929  utf8_bytes_filled = 4;
4930  }
4931  else
4932  {
4933  // unknown character
4934  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4935  utf8_bytes_filled = 1;
4936  }
4937  }
4938  }
4939 };
4940 
4941 template<typename BaseInputAdapter>
4942 struct wide_string_input_helper<BaseInputAdapter, 2>
4943 {
4944  // UTF-16
4945  static void fill_buffer(BaseInputAdapter& input,
4946  std::array<std::char_traits<char>::int_type, 4>& utf8_bytes,
4947  size_t& utf8_bytes_index,
4948  size_t& utf8_bytes_filled)
4949  {
4950  utf8_bytes_index = 0;
4951 
4952  if (JSON_HEDLEY_UNLIKELY(input.empty()))
4953  {
4954  utf8_bytes[0] = std::char_traits<char>::eof();
4955  utf8_bytes_filled = 1;
4956  }
4957  else
4958  {
4959  // get the current character
4960  const auto wc = input.get_character();
4961 
4962  // UTF-16 to UTF-8 encoding
4963  if (wc < 0x80)
4964  {
4965  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4966  utf8_bytes_filled = 1;
4967  }
4968  else if (wc <= 0x7FF)
4969  {
4970  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xC0u | ((static_cast<unsigned int>(wc) >> 6u)));
4971  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
4972  utf8_bytes_filled = 2;
4973  }
4974  else if (0xD800 > wc || wc >= 0xE000)
4975  {
4976  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xE0u | ((static_cast<unsigned int>(wc) >> 12u)));
4977  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((static_cast<unsigned int>(wc) >> 6u) & 0x3Fu));
4978  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | (static_cast<unsigned int>(wc) & 0x3Fu));
4979  utf8_bytes_filled = 3;
4980  }
4981  else
4982  {
4983  if (JSON_HEDLEY_UNLIKELY(!input.empty()))
4984  {
4985  const auto wc2 = static_cast<unsigned int>(input.get_character());
4986  const auto charcode = 0x10000u + (((static_cast<unsigned int>(wc) & 0x3FFu) << 10u) | (wc2 & 0x3FFu));
4987  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(0xF0u | (charcode >> 18u));
4988  utf8_bytes[1] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 12u) & 0x3Fu));
4989  utf8_bytes[2] = static_cast<std::char_traits<char>::int_type>(0x80u | ((charcode >> 6u) & 0x3Fu));
4990  utf8_bytes[3] = static_cast<std::char_traits<char>::int_type>(0x80u | (charcode & 0x3Fu));
4991  utf8_bytes_filled = 4;
4992  }
4993  else
4994  {
4995  utf8_bytes[0] = static_cast<std::char_traits<char>::int_type>(wc);
4996  utf8_bytes_filled = 1;
4997  }
4998  }
4999  }
5000  }
5001 };
5002 
5003 // Wraps another input apdater to convert wide character types into individual bytes.
5004 template<typename BaseInputAdapter, typename WideCharType>
5006 {
5007  public:
5008  using char_type = char;
5009 
5010  wide_string_input_adapter(BaseInputAdapter base)
5011  : base_adapter(base) {}
5012 
5013  typename std::char_traits<char>::int_type get_character() noexcept
5014  {
5015  // check if buffer needs to be filled
5017  {
5018  fill_buffer<sizeof(WideCharType)>();
5019 
5020  JSON_ASSERT(utf8_bytes_filled > 0);
5021  JSON_ASSERT(utf8_bytes_index == 0);
5022  }
5023 
5024  // use buffer
5025  JSON_ASSERT(utf8_bytes_filled > 0);
5026  JSON_ASSERT(utf8_bytes_index < utf8_bytes_filled);
5027  return utf8_bytes[utf8_bytes_index++];
5028  }
5029 
5030  private:
5031  BaseInputAdapter base_adapter;
5032 
5033  template<size_t T>
5034  void fill_buffer()
5035  {
5037  }
5038 
5039  /// a buffer for UTF-8 bytes
5040  std::array<std::char_traits<char>::int_type, 4> utf8_bytes = {{0, 0, 0, 0}};
5041 
5042  /// index to the utf8_codes array for the next valid byte
5043  std::size_t utf8_bytes_index = 0;
5044  /// number of valid bytes in the utf8_codes array
5045  std::size_t utf8_bytes_filled = 0;
5046 };
5047 
5048 
5049 template<typename IteratorType, typename Enable = void>
5051 {
5052  using iterator_type = IteratorType;
5053  using char_type = typename std::iterator_traits<iterator_type>::value_type;
5055 
5056  static adapter_type create(IteratorType first, IteratorType last)
5057  {
5058  return adapter_type(std::move(first), std::move(last));
5059  }
5060 };
5061 
5062 template<typename T>
5064 {
5065  using value_type = typename std::iterator_traits<T>::value_type;
5066  enum
5067  {
5068  value = sizeof(value_type) > 1
5069  };
5070 };
5071 
5072 template<typename IteratorType>
5073 struct iterator_input_adapter_factory<IteratorType, enable_if_t<is_iterator_of_multibyte<IteratorType>::value>>
5074 {
5075  using iterator_type = IteratorType;
5076  using char_type = typename std::iterator_traits<iterator_type>::value_type;
5079 
5080  static adapter_type create(IteratorType first, IteratorType last)
5081  {
5082  return adapter_type(base_adapter_type(std::move(first), std::move(last)));
5083  }
5084 };
5085 
5086 // General purpose iterator-based input
5087 template<typename IteratorType>
5088 typename iterator_input_adapter_factory<IteratorType>::adapter_type input_adapter(IteratorType first, IteratorType last)
5089 {
5090  using factory_type = iterator_input_adapter_factory<IteratorType>;
5091  return factory_type::create(first, last);
5092 }
5093 
5094 // Convenience shorthand from container to iterator
5095 template<typename ContainerType>
5096 auto input_adapter(const ContainerType& container) -> decltype(input_adapter(begin(container), end(container)))
5097 {
5098  // Enable ADL
5099  using std::begin;
5100  using std::end;
5101 
5102  return input_adapter(begin(container), end(container));
5103 }
5104 
5105 // Special cases with fast paths
5106 inline file_input_adapter input_adapter(std::FILE* file)
5107 {
5108  return file_input_adapter(file);
5109 }
5110 
5111 inline input_stream_adapter input_adapter(std::istream& stream)
5112 {
5113  return input_stream_adapter(stream);
5114 }
5115 
5116 inline input_stream_adapter input_adapter(std::istream&& stream)
5117 {
5118  return input_stream_adapter(stream);
5119 }
5120 
5121 using contiguous_bytes_input_adapter = decltype(input_adapter(std::declval<const char*>(), std::declval<const char*>()));
5122 
5123 // Null-delimited strings, and the like.
5124 template < typename CharT,
5125  typename std::enable_if <
5126  std::is_pointer<CharT>::value&&
5127  !std::is_array<CharT>::value&&
5128  std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5129  sizeof(typename std::remove_pointer<CharT>::type) == 1,
5130  int >::type = 0 >
5131 contiguous_bytes_input_adapter input_adapter(CharT b)
5132 {
5133  auto length = std::strlen(reinterpret_cast<const char*>(b));
5134  const auto* ptr = reinterpret_cast<const char*>(b);
5135  return input_adapter(ptr, ptr + length);
5136 }
5137 
5138 template<typename T, std::size_t N>
5139 auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N))
5140 {
5141  return input_adapter(array, array + N);
5142 }
5143 
5144 // This class only handles inputs of input_buffer_adapter type.
5145 // It's required so that expressions like {ptr, len} can be implicitely casted
5146 // to the correct adapter.
5148 {
5149  public:
5150  template < typename CharT,
5151  typename std::enable_if <
5152  std::is_pointer<CharT>::value&&
5153  std::is_integral<typename std::remove_pointer<CharT>::type>::value&&
5154  sizeof(typename std::remove_pointer<CharT>::type) == 1,
5155  int >::type = 0 >
5156  span_input_adapter(CharT b, std::size_t l)
5157  : ia(reinterpret_cast<const char*>(b), reinterpret_cast<const char*>(b) + l) {}
5158 
5159  template<class IteratorType,
5160  typename std::enable_if<
5161  std::is_same<typename iterator_traits<IteratorType>::iterator_category, std::random_access_iterator_tag>::value,
5162  int>::type = 0>
5163  span_input_adapter(IteratorType first, IteratorType last)
5164  : ia(input_adapter(first, last)) {}
5165 
5166  contiguous_bytes_input_adapter&& get()
5167  {
5168  return std::move(ia);
5169  }
5170 
5171  private:
5172  contiguous_bytes_input_adapter ia;
5173 };
5174 } // namespace detail
5175 } // namespace nlohmann
5176 
5177 // #include <nlohmann/detail/input/json_sax.hpp>
5178 
5179 
5180 #include <cstddef>
5181 #include <string> // string
5182 #include <utility> // move
5183 #include <vector> // vector
5184 
5185 // #include <nlohmann/detail/exceptions.hpp>
5186 
5187 // #include <nlohmann/detail/macro_scope.hpp>
5188 
5189 
5190 namespace nlohmann
5191 {
5192 
5193 /*!
5194 @brief SAX interface
5195 
5196 This class describes the SAX interface used by @ref nlohmann::json::sax_parse.
5197 Each function is called in different situations while the input is parsed. The
5198 boolean return value informs the parser whether to continue processing the
5199 input.
5200 */
5201 template<typename BasicJsonType>
5202 struct json_sax
5203 {
5204  using number_integer_t = typename BasicJsonType::number_integer_t;
5205  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5206  using number_float_t = typename BasicJsonType::number_float_t;
5207  using string_t = typename BasicJsonType::string_t;
5208  using binary_t = typename BasicJsonType::binary_t;
5209 
5210  /*!
5211  @brief a null value was read
5212  @return whether parsing should proceed
5213  */
5214  virtual bool null() = 0;
5215 
5216  /*!
5217  @brief a boolean value was read
5218  @param[in] val boolean value
5219  @return whether parsing should proceed
5220  */
5221  virtual bool boolean(bool val) = 0;
5222 
5223  /*!
5224  @brief an integer number was read
5225  @param[in] val integer value
5226  @return whether parsing should proceed
5227  */
5228  virtual bool number_integer(number_integer_t val) = 0;
5229 
5230  /*!
5231  @brief an unsigned integer number was read
5232  @param[in] val unsigned integer value
5233  @return whether parsing should proceed
5234  */
5235  virtual bool number_unsigned(number_unsigned_t val) = 0;
5236 
5237  /*!
5238  @brief an floating-point number was read
5239  @param[in] val floating-point value
5240  @param[in] s raw token value
5241  @return whether parsing should proceed
5242  */
5243  virtual bool number_float(number_float_t val, const string_t& s) = 0;
5244 
5245  /*!
5246  @brief a string was read
5247  @param[in] val string value
5248  @return whether parsing should proceed
5249  @note It is safe to move the passed string.
5250  */
5251  virtual bool string(string_t& val) = 0;
5252 
5253  /*!
5254  @brief a binary string was read
5255  @param[in] val binary value
5256  @return whether parsing should proceed
5257  @note It is safe to move the passed binary.
5258  */
5259  virtual bool binary(binary_t& val) = 0;
5260 
5261  /*!
5262  @brief the beginning of an object was read
5263  @param[in] elements number of object elements or -1 if unknown
5264  @return whether parsing should proceed
5265  @note binary formats may report the number of elements
5266  */
5267  virtual bool start_object(std::size_t elements) = 0;
5268 
5269  /*!
5270  @brief an object key was read
5271  @param[in] val object key
5272  @return whether parsing should proceed
5273  @note It is safe to move the passed string.
5274  */
5275  virtual bool key(string_t& val) = 0;
5276 
5277  /*!
5278  @brief the end of an object was read
5279  @return whether parsing should proceed
5280  */
5281  virtual bool end_object() = 0;
5282 
5283  /*!
5284  @brief the beginning of an array was read
5285  @param[in] elements number of array elements or -1 if unknown
5286  @return whether parsing should proceed
5287  @note binary formats may report the number of elements
5288  */
5289  virtual bool start_array(std::size_t elements) = 0;
5290 
5291  /*!
5292  @brief the end of an array was read
5293  @return whether parsing should proceed
5294  */
5295  virtual bool end_array() = 0;
5296 
5297  /*!
5298  @brief a parse error occurred
5299  @param[in] position the position in the input where the error occurs
5300  @param[in] last_token the last read token
5301  @param[in] ex an exception object describing the error
5302  @return whether parsing should proceed (must return false)
5303  */
5304  virtual bool parse_error(std::size_t position,
5305  const std::string& last_token,
5306  const detail::exception& ex) = 0;
5307 
5308  virtual ~json_sax() = default;
5309 };
5310 
5311 
5312 namespace detail
5313 {
5314 /*!
5315 @brief SAX implementation to create a JSON value from SAX events
5316 
5317 This class implements the @ref json_sax interface and processes the SAX events
5318 to create a JSON value which makes it basically a DOM parser. The structure or
5319 hierarchy of the JSON value is managed by the stack `ref_stack` which contains
5320 a pointer to the respective array or object for each recursion depth.
5321 
5322 After successful parsing, the value that is passed by reference to the
5323 constructor contains the parsed value.
5324 
5325 @tparam BasicJsonType the JSON type
5326 */
5327 template<typename BasicJsonType>
5329 {
5330  public:
5331  using number_integer_t = typename BasicJsonType::number_integer_t;
5332  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5333  using number_float_t = typename BasicJsonType::number_float_t;
5334  using string_t = typename BasicJsonType::string_t;
5335  using binary_t = typename BasicJsonType::binary_t;
5336 
5337  /*!
5338  @param[in, out] r reference to a JSON value that is manipulated while
5339  parsing
5340  @param[in] allow_exceptions_ whether parse errors yield exceptions
5341  */
5342  explicit json_sax_dom_parser(BasicJsonType& r, const bool allow_exceptions_ = true)
5343  : root(r), allow_exceptions(allow_exceptions_)
5344  {}
5345 
5346  // make class move-only
5347  json_sax_dom_parser(const json_sax_dom_parser&) = delete;
5349  json_sax_dom_parser& operator=(const json_sax_dom_parser&) = delete;
5350  json_sax_dom_parser& operator=(json_sax_dom_parser&&) = default;
5351  ~json_sax_dom_parser() = default;
5352 
5353  bool null()
5354  {
5355  handle_value(nullptr);
5356  return true;
5357  }
5358 
5359  bool boolean(bool val)
5360  {
5361  handle_value(val);
5362  return true;
5363  }
5364 
5365  bool number_integer(number_integer_t val)
5366  {
5367  handle_value(val);
5368  return true;
5369  }
5370 
5371  bool number_unsigned(number_unsigned_t val)
5372  {
5373  handle_value(val);
5374  return true;
5375  }
5376 
5377  bool number_float(number_float_t val, const string_t& /*unused*/)
5378  {
5379  handle_value(val);
5380  return true;
5381  }
5382 
5383  bool string(string_t& val)
5384  {
5385  handle_value(val);
5386  return true;
5387  }
5388 
5389  bool binary(binary_t& val)
5390  {
5391  handle_value(std::move(val));
5392  return true;
5393  }
5394 
5395  bool start_object(std::size_t len)
5396  {
5397  ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
5398 
5399  if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5400  {
5401  JSON_THROW(out_of_range::create(408,
5402  "excessive object size: " + std::to_string(len)));
5403  }
5404 
5405  return true;
5406  }
5407 
5408  bool key(string_t& val)
5409  {
5410  // add null at given key and store the reference for later
5411  object_element = &(ref_stack.back()->m_value.object->operator[](val));
5412  return true;
5413  }
5414 
5415  bool end_object()
5416  {
5417  ref_stack.pop_back();
5418  return true;
5419  }
5420 
5421  bool start_array(std::size_t len)
5422  {
5423  ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
5424 
5425  if (JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5426  {
5427  JSON_THROW(out_of_range::create(408,
5428  "excessive array size: " + std::to_string(len)));
5429  }
5430 
5431  return true;
5432  }
5433 
5434  bool end_array()
5435  {
5436  ref_stack.pop_back();
5437  return true;
5438  }
5439 
5440  template<class Exception>
5441  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
5442  const Exception& ex)
5443  {
5444  errored = true;
5445  static_cast<void>(ex);
5446  if (allow_exceptions)
5447  {
5448  JSON_THROW(ex);
5449  }
5450  return false;
5451  }
5452 
5453  constexpr bool is_errored() const
5454  {
5455  return errored;
5456  }
5457 
5458  private:
5459  /*!
5460  @invariant If the ref stack is empty, then the passed value will be the new
5461  root.
5462  @invariant If the ref stack contains a value, then it is an array or an
5463  object to which we can add elements
5464  */
5465  template<typename Value>
5466  JSON_HEDLEY_RETURNS_NON_NULL
5467  BasicJsonType* handle_value(Value&& v)
5468  {
5469  if (ref_stack.empty())
5470  {
5471  root = BasicJsonType(std::forward<Value>(v));
5472  return &root;
5473  }
5474 
5475  JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
5476 
5477  if (ref_stack.back()->is_array())
5478  {
5479  ref_stack.back()->m_value.array->emplace_back(std::forward<Value>(v));
5480  return &(ref_stack.back()->m_value.array->back());
5481  }
5482 
5483  JSON_ASSERT(ref_stack.back()->is_object());
5484  JSON_ASSERT(object_element);
5485  *object_element = BasicJsonType(std::forward<Value>(v));
5486  return object_element;
5487  }
5488 
5489  /// the parsed JSON value
5490  BasicJsonType& root;
5491  /// stack to model hierarchy of values
5492  std::vector<BasicJsonType*> ref_stack {};
5493  /// helper to hold the reference for the next object element
5494  BasicJsonType* object_element = nullptr;
5495  /// whether a syntax error occurred
5496  bool errored = false;
5497  /// whether to throw exceptions in case of errors
5498  const bool allow_exceptions = true;
5499 };
5500 
5501 template<typename BasicJsonType>
5503 {
5504  public:
5505  using number_integer_t = typename BasicJsonType::number_integer_t;
5506  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5507  using number_float_t = typename BasicJsonType::number_float_t;
5508  using string_t = typename BasicJsonType::string_t;
5509  using binary_t = typename BasicJsonType::binary_t;
5510  using parser_callback_t = typename BasicJsonType::parser_callback_t;
5511  using parse_event_t = typename BasicJsonType::parse_event_t;
5512 
5513  json_sax_dom_callback_parser(BasicJsonType& r,
5514  const parser_callback_t cb,
5515  const bool allow_exceptions_ = true)
5516  : root(r), callback(cb), allow_exceptions(allow_exceptions_)
5517  {
5518  keep_stack.push_back(true);
5519  }
5520 
5521  // make class move-only
5524  json_sax_dom_callback_parser& operator=(const json_sax_dom_callback_parser&) = delete;
5526  ~json_sax_dom_callback_parser() = default;
5527 
5528  bool null()
5529  {
5530  handle_value(nullptr);
5531  return true;
5532  }
5533 
5534  bool boolean(bool val)
5535  {
5536  handle_value(val);
5537  return true;
5538  }
5539 
5540  bool number_integer(number_integer_t val)
5541  {
5542  handle_value(val);
5543  return true;
5544  }
5545 
5546  bool number_unsigned(number_unsigned_t val)
5547  {
5548  handle_value(val);
5549  return true;
5550  }
5551 
5552  bool number_float(number_float_t val, const string_t& /*unused*/)
5553  {
5554  handle_value(val);
5555  return true;
5556  }
5557 
5558  bool string(string_t& val)
5559  {
5560  handle_value(val);
5561  return true;
5562  }
5563 
5564  bool binary(binary_t& val)
5565  {
5566  handle_value(std::move(val));
5567  return true;
5568  }
5569 
5570  bool start_object(std::size_t len)
5571  {
5572  // check callback for object start
5573  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::object_start, discarded);
5574  keep_stack.push_back(keep);
5575 
5576  auto val = handle_value(BasicJsonType::value_t::object, true);
5577  ref_stack.push_back(val.second);
5578 
5579  // check object limit
5580  if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5581  {
5582  JSON_THROW(out_of_range::create(408, "excessive object size: " + std::to_string(len)));
5583  }
5584 
5585  return true;
5586  }
5587 
5588  bool key(string_t& val)
5589  {
5590  BasicJsonType k = BasicJsonType(val);
5591 
5592  // check callback for key
5593  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::key, k);
5594  key_keep_stack.push_back(keep);
5595 
5596  // add discarded value at given key and store the reference for later
5597  if (keep && ref_stack.back())
5598  {
5599  object_element = &(ref_stack.back()->m_value.object->operator[](val) = discarded);
5600  }
5601 
5602  return true;
5603  }
5604 
5605  bool end_object()
5606  {
5607  if (ref_stack.back() && !callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
5608  {
5609  // discard object
5610  *ref_stack.back() = discarded;
5611  }
5612 
5613  JSON_ASSERT(!ref_stack.empty());
5614  JSON_ASSERT(!keep_stack.empty());
5615  ref_stack.pop_back();
5616  keep_stack.pop_back();
5617 
5618  if (!ref_stack.empty() && ref_stack.back() && ref_stack.back()->is_structured())
5619  {
5620  // remove discarded value
5621  for (auto it = ref_stack.back()->begin(); it != ref_stack.back()->end(); ++it)
5622  {
5623  if (it->is_discarded())
5624  {
5625  ref_stack.back()->erase(it);
5626  break;
5627  }
5628  }
5629  }
5630 
5631  return true;
5632  }
5633 
5634  bool start_array(std::size_t len)
5635  {
5636  const bool keep = callback(static_cast<int>(ref_stack.size()), parse_event_t::array_start, discarded);
5637  keep_stack.push_back(keep);
5638 
5639  auto val = handle_value(BasicJsonType::value_t::array, true);
5640  ref_stack.push_back(val.second);
5641 
5642  // check array limit
5643  if (ref_stack.back() && JSON_HEDLEY_UNLIKELY(len != std::size_t(-1) && len > ref_stack.back()->max_size()))
5644  {
5645  JSON_THROW(out_of_range::create(408, "excessive array size: " + std::to_string(len)));
5646  }
5647 
5648  return true;
5649  }
5650 
5651  bool end_array()
5652  {
5653  bool keep = true;
5654 
5655  if (ref_stack.back())
5656  {
5657  keep = callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::array_end, *ref_stack.back());
5658  if (!keep)
5659  {
5660  // discard array
5661  *ref_stack.back() = discarded;
5662  }
5663  }
5664 
5665  JSON_ASSERT(!ref_stack.empty());
5666  JSON_ASSERT(!keep_stack.empty());
5667  ref_stack.pop_back();
5668  keep_stack.pop_back();
5669 
5670  // remove discarded value
5671  if (!keep && !ref_stack.empty() && ref_stack.back()->is_array())
5672  {
5673  ref_stack.back()->m_value.array->pop_back();
5674  }
5675 
5676  return true;
5677  }
5678 
5679  template<class Exception>
5680  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/,
5681  const Exception& ex)
5682  {
5683  errored = true;
5684  static_cast<void>(ex);
5685  if (allow_exceptions)
5686  {
5687  JSON_THROW(ex);
5688  }
5689  return false;
5690  }
5691 
5692  constexpr bool is_errored() const
5693  {
5694  return errored;
5695  }
5696 
5697  private:
5698  /*!
5699  @param[in] v value to add to the JSON value we build during parsing
5700  @param[in] skip_callback whether we should skip calling the callback
5701  function; this is required after start_array() and
5702  start_object() SAX events, because otherwise we would call the
5703  callback function with an empty array or object, respectively.
5704 
5705  @invariant If the ref stack is empty, then the passed value will be the new
5706  root.
5707  @invariant If the ref stack contains a value, then it is an array or an
5708  object to which we can add elements
5709 
5710  @return pair of boolean (whether value should be kept) and pointer (to the
5711  passed value in the ref_stack hierarchy; nullptr if not kept)
5712  */
5713  template<typename Value>
5714  std::pair<bool, BasicJsonType*> handle_value(Value&& v, const bool skip_callback = false)
5715  {
5716  JSON_ASSERT(!keep_stack.empty());
5717 
5718  // do not handle this value if we know it would be added to a discarded
5719  // container
5720  if (!keep_stack.back())
5721  {
5722  return {false, nullptr};
5723  }
5724 
5725  // create value
5726  auto value = BasicJsonType(std::forward<Value>(v));
5727 
5728  // check callback
5729  const bool keep = skip_callback || callback(static_cast<int>(ref_stack.size()), parse_event_t::value, value);
5730 
5731  // do not handle this value if we just learnt it shall be discarded
5732  if (!keep)
5733  {
5734  return {false, nullptr};
5735  }
5736 
5737  if (ref_stack.empty())
5738  {
5739  root = std::move(value);
5740  return {true, &root};
5741  }
5742 
5743  // skip this value if we already decided to skip the parent
5744  // (https://github.com/nlohmann/json/issues/971#issuecomment-413678360)
5745  if (!ref_stack.back())
5746  {
5747  return {false, nullptr};
5748  }
5749 
5750  // we now only expect arrays and objects
5751  JSON_ASSERT(ref_stack.back()->is_array() || ref_stack.back()->is_object());
5752 
5753  // array
5754  if (ref_stack.back()->is_array())
5755  {
5756  ref_stack.back()->m_value.array->push_back(std::move(value));
5757  return {true, &(ref_stack.back()->m_value.array->back())};
5758  }
5759 
5760  // object
5761  JSON_ASSERT(ref_stack.back()->is_object());
5762  // check if we should store an element for the current key
5763  JSON_ASSERT(!key_keep_stack.empty());
5764  const bool store_element = key_keep_stack.back();
5765  key_keep_stack.pop_back();
5766 
5767  if (!store_element)
5768  {
5769  return {false, nullptr};
5770  }
5771 
5772  JSON_ASSERT(object_element);
5773  *object_element = std::move(value);
5774  return {true, object_element};
5775  }
5776 
5777  /// the parsed JSON value
5778  BasicJsonType& root;
5779  /// stack to model hierarchy of values
5780  std::vector<BasicJsonType*> ref_stack {};
5781  /// stack to manage which values to keep
5782  std::vector<bool> keep_stack {};
5783  /// stack to manage which object keys to keep
5784  std::vector<bool> key_keep_stack {};
5785  /// helper to hold the reference for the next object element
5786  BasicJsonType* object_element = nullptr;
5787  /// whether a syntax error occurred
5788  bool errored = false;
5789  /// callback function
5790  const parser_callback_t callback = nullptr;
5791  /// whether to throw exceptions in case of errors
5792  const bool allow_exceptions = true;
5793  /// a discarded value for the callback
5794  BasicJsonType discarded = BasicJsonType::value_t::discarded;
5795 };
5796 
5797 template<typename BasicJsonType>
5799 {
5800  public:
5801  using number_integer_t = typename BasicJsonType::number_integer_t;
5802  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5803  using number_float_t = typename BasicJsonType::number_float_t;
5804  using string_t = typename BasicJsonType::string_t;
5805  using binary_t = typename BasicJsonType::binary_t;
5806 
5807  bool null()
5808  {
5809  return true;
5810  }
5811 
5812  bool boolean(bool /*unused*/)
5813  {
5814  return true;
5815  }
5816 
5817  bool number_integer(number_integer_t /*unused*/)
5818  {
5819  return true;
5820  }
5821 
5822  bool number_unsigned(number_unsigned_t /*unused*/)
5823  {
5824  return true;
5825  }
5826 
5827  bool number_float(number_float_t /*unused*/, const string_t& /*unused*/)
5828  {
5829  return true;
5830  }
5831 
5832  bool string(string_t& /*unused*/)
5833  {
5834  return true;
5835  }
5836 
5837  bool binary(binary_t& /*unused*/)
5838  {
5839  return true;
5840  }
5841 
5842  bool start_object(std::size_t /*unused*/ = std::size_t(-1))
5843  {
5844  return true;
5845  }
5846 
5847  bool key(string_t& /*unused*/)
5848  {
5849  return true;
5850  }
5851 
5852  bool end_object()
5853  {
5854  return true;
5855  }
5856 
5857  bool start_array(std::size_t /*unused*/ = std::size_t(-1))
5858  {
5859  return true;
5860  }
5861 
5862  bool end_array()
5863  {
5864  return true;
5865  }
5866 
5867  bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const detail::exception& /*unused*/)
5868  {
5869  return false;
5870  }
5871 };
5872 } // namespace detail
5873 
5874 } // namespace nlohmann
5875 
5876 // #include <nlohmann/detail/input/lexer.hpp>
5877 
5878 
5879 #include <array> // array
5880 #include <clocale> // localeconv
5881 #include <cstddef> // size_t
5882 #include <cstdio> // snprintf
5883 #include <cstdlib> // strtof, strtod, strtold, strtoll, strtoull
5884 #include <initializer_list> // initializer_list
5885 #include <string> // char_traits, string
5886 #include <utility> // move
5887 #include <vector> // vector
5888 
5889 // #include <nlohmann/detail/input/input_adapters.hpp>
5890 
5891 // #include <nlohmann/detail/input/position_t.hpp>
5892 
5893 // #include <nlohmann/detail/macro_scope.hpp>
5894 
5895 
5896 namespace nlohmann
5897 {
5898 namespace detail
5899 {
5900 ///////////
5901 // lexer //
5902 ///////////
5903 
5904 template<typename BasicJsonType>
5906 {
5907  public:
5908  /// token types for the parser
5909  enum class token_type
5910  {
5911  uninitialized, ///< indicating the scanner is uninitialized
5912  literal_true, ///< the `true` literal
5913  literal_false, ///< the `false` literal
5914  literal_null, ///< the `null` literal
5915  value_string, ///< a string -- use get_string() for actual value
5916  value_unsigned, ///< an unsigned integer -- use get_number_unsigned() for actual value
5917  value_integer, ///< a signed integer -- use get_number_integer() for actual value
5918  value_float, ///< an floating point number -- use get_number_float() for actual value
5919  begin_array, ///< the character for array begin `[`
5920  begin_object, ///< the character for object begin `{`
5921  end_array, ///< the character for array end `]`
5922  end_object, ///< the character for object end `}`
5923  name_separator, ///< the name separator `:`
5924  value_separator, ///< the value separator `,`
5925  parse_error, ///< indicating a parse error
5926  end_of_input, ///< indicating the end of the input buffer
5927  literal_or_value ///< a literal or the begin of a value (only for diagnostics)
5928  };
5929 
5930  /// return name of values of type token_type (only used for errors)
5931  JSON_HEDLEY_RETURNS_NON_NULL
5932  JSON_HEDLEY_CONST
5933  static const char* token_type_name(const token_type t) noexcept
5934  {
5935  switch (t)
5936  {
5938  return "<uninitialized>";
5940  return "true literal";
5942  return "false literal";
5944  return "null literal";
5946  return "string literal";
5950  return "number literal";
5952  return "'['";
5954  return "'{'";
5955  case token_type::end_array:
5956  return "']'";
5958  return "'}'";
5960  return "':'";
5962  return "','";
5964  return "<parse error>";
5966  return "end of input";
5968  return "'[', '{', or a literal";
5969  // LCOV_EXCL_START
5970  default: // catch non-enum values
5971  return "unknown token";
5972  // LCOV_EXCL_STOP
5973  }
5974  }
5975 };
5976 /*!
5977 @brief lexical analysis
5978 
5979 This class organizes the lexical analysis during JSON deserialization.
5980 */
5981 template<typename BasicJsonType, typename InputAdapterType>
5982 class lexer : public lexer_base<BasicJsonType>
5983 {
5984  using number_integer_t = typename BasicJsonType::number_integer_t;
5985  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
5986  using number_float_t = typename BasicJsonType::number_float_t;
5987  using string_t = typename BasicJsonType::string_t;
5988  using char_type = typename InputAdapterType::char_type;
5989  using char_int_type = typename std::char_traits<char_type>::int_type;
5990 
5991  public:
5993 
5994  explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false)
5995  : ia(std::move(adapter))
5996  , ignore_comments(ignore_comments_)
5997  , decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
5998  {}
5999 
6000  // delete because of pointer members
6001  lexer(const lexer&) = delete;
6002  lexer(lexer&&) = default;
6003  lexer& operator=(lexer&) = delete;
6004  lexer& operator=(lexer&&) = default;
6005  ~lexer() = default;
6006 
6007  private:
6008  /////////////////////
6009  // locales
6010  /////////////////////
6011 
6012  /// return the locale-dependent decimal point
6013  JSON_HEDLEY_PURE
6014  static char get_decimal_point() noexcept
6015  {
6016  const auto* loc = localeconv();
6017  JSON_ASSERT(loc != nullptr);
6018  return (loc->decimal_point == nullptr) ? '.' : *(loc->decimal_point);
6019  }
6020 
6021  /////////////////////
6022  // scan functions
6023  /////////////////////
6024 
6025  /*!
6026  @brief get codepoint from 4 hex characters following `\u`
6027 
6028  For input "\u c1 c2 c3 c4" the codepoint is:
6029  (c1 * 0x1000) + (c2 * 0x0100) + (c3 * 0x0010) + c4
6030  = (c1 << 12) + (c2 << 8) + (c3 << 4) + (c4 << 0)
6031 
6032  Furthermore, the possible characters '0'..'9', 'A'..'F', and 'a'..'f'
6033  must be converted to the integers 0x0..0x9, 0xA..0xF, 0xA..0xF, resp. The
6034  conversion is done by subtracting the offset (0x30, 0x37, and 0x57)
6035  between the ASCII value of the character and the desired integer value.
6036 
6037  @return codepoint (0x0000..0xFFFF) or -1 in case of an error (e.g. EOF or
6038  non-hex character)
6039  */
6041  {
6042  // this function only makes sense after reading `\u`
6043  JSON_ASSERT(current == 'u');
6044  int codepoint = 0;
6045 
6046  const auto factors = { 12u, 8u, 4u, 0u };
6047  for (const auto factor : factors)
6048  {
6049  get();
6050 
6051  if (current >= '0' && current <= '9')
6052  {
6053  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x30u) << factor);
6054  }
6055  else if (current >= 'A' && current <= 'F')
6056  {
6057  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x37u) << factor);
6058  }
6059  else if (current >= 'a' && current <= 'f')
6060  {
6061  codepoint += static_cast<int>((static_cast<unsigned int>(current) - 0x57u) << factor);
6062  }
6063  else
6064  {
6065  return -1;
6066  }
6067  }
6068 
6069  JSON_ASSERT(0x0000 <= codepoint && codepoint <= 0xFFFF);
6070  return codepoint;
6071  }
6072 
6073  /*!
6074  @brief check if the next byte(s) are inside a given range
6075 
6076  Adds the current byte and, for each passed range, reads a new byte and
6077  checks if it is inside the range. If a violation was detected, set up an
6078  error message and return false. Otherwise, return true.
6079 
6080  @param[in] ranges list of integers; interpreted as list of pairs of
6081  inclusive lower and upper bound, respectively
6082 
6083  @pre The passed list @a ranges must have 2, 4, or 6 elements; that is,
6084  1, 2, or 3 pairs. This precondition is enforced by an assertion.
6085 
6086  @return true if and only if no range violation was detected
6087  */
6088  bool next_byte_in_range(std::initializer_list<char_int_type> ranges)
6089  {
6090  JSON_ASSERT(ranges.size() == 2 || ranges.size() == 4 || ranges.size() == 6);
6091  add(current);
6092 
6093  for (auto range = ranges.begin(); range != ranges.end(); ++range)
6094  {
6095  get();
6096  if (JSON_HEDLEY_LIKELY(*range <= current && current <= *(++range)))
6097  {
6098  add(current);
6099  }
6100  else
6101  {
6102  error_message = "invalid string: ill-formed UTF-8 byte";
6103  return false;
6104  }
6105  }
6106 
6107  return true;
6108  }
6109 
6110  /*!
6111  @brief scan a string literal
6112 
6113  This function scans a string according to Sect. 7 of RFC 7159. While
6114  scanning, bytes are escaped and copied into buffer token_buffer. Then the
6115  function returns successfully, token_buffer is *not* null-terminated (as it
6116  may contain \0 bytes), and token_buffer.size() is the number of bytes in the
6117  string.
6118 
6119  @return token_type::value_string if string could be successfully scanned,
6120  token_type::parse_error otherwise
6121 
6122  @note In case of errors, variable error_message contains a textual
6123  description.
6124  */
6126  {
6127  // reset token_buffer (ignore opening quote)
6128  reset();
6129 
6130  // we entered the function by reading an open quote
6131  JSON_ASSERT(current == '\"');
6132 
6133  while (true)
6134  {
6135  // get next character
6136  switch (get())
6137  {
6138  // end of file while parsing string
6139  case std::char_traits<char_type>::eof():
6140  {
6141  error_message = "invalid string: missing closing quote";
6142  return token_type::parse_error;
6143  }
6144 
6145  // closing quote
6146  case '\"':
6147  {
6148  return token_type::value_string;
6149  }
6150 
6151  // escapes
6152  case '\\':
6153  {
6154  switch (get())
6155  {
6156  // quotation mark
6157  case '\"':
6158  add('\"');
6159  break;
6160  // reverse solidus
6161  case '\\':
6162  add('\\');
6163  break;
6164  // solidus
6165  case '/':
6166  add('/');
6167  break;
6168  // backspace
6169  case 'b':
6170  add('\b');
6171  break;
6172  // form feed
6173  case 'f':
6174  add('\f');
6175  break;
6176  // line feed
6177  case 'n':
6178  add('\n');
6179  break;
6180  // carriage return
6181  case 'r':
6182  add('\r');
6183  break;
6184  // tab
6185  case 't':
6186  add('\t');
6187  break;
6188 
6189  // unicode escapes
6190  case 'u':
6191  {
6192  const int codepoint1 = get_codepoint();
6193  int codepoint = codepoint1; // start with codepoint1
6194 
6195  if (JSON_HEDLEY_UNLIKELY(codepoint1 == -1))
6196  {
6197  error_message = "invalid string: '\\u' must be followed by 4 hex digits";
6198  return token_type::parse_error;
6199  }
6200 
6201  // check if code point is a high surrogate
6202  if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
6203  {
6204  // expect next \uxxxx entry
6205  if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
6206  {
6207  const int codepoint2 = get_codepoint();
6208 
6209  if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
6210  {
6211  error_message = "invalid string: '\\u' must be followed by 4 hex digits";
6212  return token_type::parse_error;
6213  }
6214 
6215  // check if codepoint2 is a low surrogate
6216  if (JSON_HEDLEY_LIKELY(0xDC00 <= codepoint2 && codepoint2 <= 0xDFFF))
6217  {
6218  // overwrite codepoint
6219  codepoint = static_cast<int>(
6220  // high surrogate occupies the most significant 22 bits
6221  (static_cast<unsigned int>(codepoint1) << 10u)
6222  // low surrogate occupies the least significant 15 bits
6223  + static_cast<unsigned int>(codepoint2)
6224  // there is still the 0xD800, 0xDC00 and 0x10000 noise
6225  // in the result so we have to subtract with:
6226  // (0xD800 << 10) + DC00 - 0x10000 = 0x35FDC00
6227  - 0x35FDC00u);
6228  }
6229  else
6230  {
6231  error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6232  return token_type::parse_error;
6233  }
6234  }
6235  else
6236  {
6237  error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
6238  return token_type::parse_error;
6239  }
6240  }
6241  else
6242  {
6243  if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
6244  {
6245  error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
6246  return token_type::parse_error;
6247  }
6248  }
6249 
6250  // result of the above calculation yields a proper codepoint
6251  JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
6252 
6253  // translate codepoint into bytes
6254  if (codepoint < 0x80)
6255  {
6256  // 1-byte characters: 0xxxxxxx (ASCII)
6257  add(static_cast<char_int_type>(codepoint));
6258  }
6259  else if (codepoint <= 0x7FF)
6260  {
6261  // 2-byte characters: 110xxxxx 10xxxxxx
6262  add(static_cast<char_int_type>(0xC0u | (static_cast<unsigned int>(codepoint) >> 6u)));
6263  add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
6264  }
6265  else if (codepoint <= 0xFFFF)
6266  {
6267  // 3-byte characters: 1110xxxx 10xxxxxx 10xxxxxx
6268  add(static_cast<char_int_type>(0xE0u | (static_cast<unsigned int>(codepoint) >> 12u)));
6269  add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6270  add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
6271  }
6272  else
6273  {
6274  // 4-byte characters: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
6275  add(static_cast<char_int_type>(0xF0u | (static_cast<unsigned int>(codepoint) >> 18u)));
6276  add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 12u) & 0x3Fu)));
6277  add(static_cast<char_int_type>(0x80u | ((static_cast<unsigned int>(codepoint) >> 6u) & 0x3Fu)));
6278  add(static_cast<char_int_type>(0x80u | (static_cast<unsigned int>(codepoint) & 0x3Fu)));
6279  }
6280 
6281  break;
6282  }
6283 
6284  // other characters after escape
6285  default:
6286  error_message = "invalid string: forbidden character after backslash";
6287  return token_type::parse_error;
6288  }
6289 
6290  break;
6291  }
6292 
6293  // invalid control characters
6294  case 0x00:
6295  {
6296  error_message = "invalid string: control character U+0000 (NUL) must be escaped to \\u0000";
6297  return token_type::parse_error;
6298  }
6299 
6300  case 0x01:
6301  {
6302  error_message = "invalid string: control character U+0001 (SOH) must be escaped to \\u0001";
6303  return token_type::parse_error;
6304  }
6305 
6306  case 0x02:
6307  {
6308  error_message = "invalid string: control character U+0002 (STX) must be escaped to \\u0002";
6309  return token_type::parse_error;
6310  }
6311 
6312  case 0x03:
6313  {
6314  error_message = "invalid string: control character U+0003 (ETX) must be escaped to \\u0003";
6315  return token_type::parse_error;
6316  }
6317 
6318  case 0x04:
6319  {
6320  error_message = "invalid string: control character U+0004 (EOT) must be escaped to \\u0004";
6321  return token_type::parse_error;
6322  }
6323 
6324  case 0x05:
6325  {
6326  error_message = "invalid string: control character U+0005 (ENQ) must be escaped to \\u0005";
6327  return token_type::parse_error;
6328  }
6329 
6330  case 0x06:
6331  {
6332  error_message = "invalid string: control character U+0006 (ACK) must be escaped to \\u0006";
6333  return token_type::parse_error;
6334  }
6335 
6336  case 0x07:
6337  {
6338  error_message = "invalid string: control character U+0007 (BEL) must be escaped to \\u0007";
6339  return token_type::parse_error;
6340  }
6341 
6342  case 0x08:
6343  {
6344  error_message = "invalid string: control character U+0008 (BS) must be escaped to \\u0008 or \\b";
6345  return token_type::parse_error;
6346  }
6347 
6348  case 0x09:
6349  {
6350  error_message = "invalid string: control character U+0009 (HT) must be escaped to \\u0009 or \\t";
6351  return token_type::parse_error;
6352  }
6353 
6354  case 0x0A:
6355  {
6356  error_message = "invalid string: control character U+000A (LF) must be escaped to \\u000A or \\n";
6357  return token_type::parse_error;
6358  }
6359 
6360  case 0x0B:
6361  {
6362  error_message = "invalid string: control character U+000B (VT) must be escaped to \\u000B";
6363  return token_type::parse_error;
6364  }
6365 
6366  case 0x0C:
6367  {
6368  error_message = "invalid string: control character U+000C (FF) must be escaped to \\u000C or \\f";
6369  return token_type::parse_error;
6370  }
6371 
6372  case 0x0D:
6373  {
6374  error_message = "invalid string: control character U+000D (CR) must be escaped to \\u000D or \\r";
6375  return token_type::parse_error;
6376  }
6377 
6378  case 0x0E:
6379  {
6380  error_message = "invalid string: control character U+000E (SO) must be escaped to \\u000E";
6381  return token_type::parse_error;
6382  }
6383 
6384  case 0x0F:
6385  {
6386  error_message = "invalid string: control character U+000F (SI) must be escaped to \\u000F";
6387  return token_type::parse_error;
6388  }
6389 
6390  case 0x10:
6391  {
6392  error_message = "invalid string: control character U+0010 (DLE) must be escaped to \\u0010";
6393  return token_type::parse_error;
6394  }
6395 
6396  case 0x11:
6397  {
6398  error_message = "invalid string: control character U+0011 (DC1) must be escaped to \\u0011";
6399  return token_type::parse_error;
6400  }
6401 
6402  case 0x12:
6403  {
6404  error_message = "invalid string: control character U+0012 (DC2) must be escaped to \\u0012";
6405  return token_type::parse_error;
6406  }
6407 
6408  case 0x13:
6409  {
6410  error_message = "invalid string: control character U+0013 (DC3) must be escaped to \\u0013";
6411  return token_type::parse_error;
6412  }
6413 
6414  case 0x14:
6415  {
6416  error_message = "invalid string: control character U+0014 (DC4) must be escaped to \\u0014";
6417  return token_type::parse_error;
6418  }
6419 
6420  case 0x15:
6421  {
6422  error_message = "invalid string: control character U+0015 (NAK) must be escaped to \\u0015";
6423  return token_type::parse_error;
6424  }
6425 
6426  case 0x16:
6427  {
6428  error_message = "invalid string: control character U+0016 (SYN) must be escaped to \\u0016";
6429  return token_type::parse_error;
6430  }
6431 
6432  case 0x17:
6433  {
6434  error_message = "invalid string: control character U+0017 (ETB) must be escaped to \\u0017";
6435  return token_type::parse_error;
6436  }
6437 
6438  case 0x18:
6439  {
6440  error_message = "invalid string: control character U+0018 (CAN) must be escaped to \\u0018";
6441  return token_type::parse_error;
6442  }
6443 
6444  case 0x19:
6445  {
6446  error_message = "invalid string: control character U+0019 (EM) must be escaped to \\u0019";
6447  return token_type::parse_error;
6448  }
6449 
6450  case 0x1A:
6451  {
6452  error_message = "invalid string: control character U+001A (SUB) must be escaped to \\u001A";
6453  return token_type::parse_error;
6454  }
6455 
6456  case 0x1B:
6457  {
6458  error_message = "invalid string: control character U+001B (ESC) must be escaped to \\u001B";
6459  return token_type::parse_error;
6460  }
6461 
6462  case 0x1C:
6463  {
6464  error_message = "invalid string: control character U+001C (FS) must be escaped to \\u001C";
6465  return token_type::parse_error;
6466  }
6467 
6468  case 0x1D:
6469  {
6470  error_message = "invalid string: control character U+001D (GS) must be escaped to \\u001D";
6471  return token_type::parse_error;
6472  }
6473 
6474  case 0x1E:
6475  {
6476  error_message = "invalid string: control character U+001E (RS) must be escaped to \\u001E";
6477  return token_type::parse_error;
6478  }
6479 
6480  case 0x1F:
6481  {
6482  error_message = "invalid string: control character U+001F (US) must be escaped to \\u001F";
6483  return token_type::parse_error;
6484  }
6485 
6486  // U+0020..U+007F (except U+0022 (quote) and U+005C (backspace))
6487  case 0x20:
6488  case 0x21:
6489  case 0x23:
6490  case 0x24:
6491  case 0x25:
6492  case 0x26:
6493  case 0x27:
6494  case 0x28:
6495  case 0x29:
6496  case 0x2A:
6497  case 0x2B:
6498  case 0x2C:
6499  case 0x2D:
6500  case 0x2E:
6501  case 0x2F:
6502  case 0x30:
6503  case 0x31:
6504  case 0x32:
6505  case 0x33:
6506  case 0x34:
6507  case 0x35:
6508  case 0x36:
6509  case 0x37:
6510  case 0x38:
6511  case 0x39:
6512  case 0x3A:
6513  case 0x3B:
6514  case 0x3C:
6515  case 0x3D:
6516  case 0x3E:
6517  case 0x3F:
6518  case 0x40:
6519  case 0x41:
6520  case 0x42:
6521  case 0x43:
6522  case 0x44:
6523  case 0x45:
6524  case 0x46:
6525  case 0x47:
6526  case 0x48:
6527  case 0x49:
6528  case 0x4A:
6529  case 0x4B:
6530  case 0x4C:
6531  case 0x4D:
6532  case 0x4E:
6533  case 0x4F:
6534  case 0x50:
6535  case 0x51:
6536  case 0x52:
6537  case 0x53:
6538  case 0x54:
6539  case 0x55:
6540  case 0x56:
6541  case 0x57:
6542  case 0x58:
6543  case 0x59:
6544  case 0x5A:
6545  case 0x5B:
6546  case 0x5D:
6547  case 0x5E:
6548  case 0x5F:
6549  case 0x60:
6550  case 0x61:
6551  case 0x62:
6552  case 0x63:
6553  case 0x64:
6554  case 0x65:
6555  case 0x66:
6556  case 0x67:
6557  case 0x68:
6558  case 0x69:
6559  case 0x6A:
6560  case 0x6B:
6561  case 0x6C:
6562  case 0x6D:
6563  case 0x6E:
6564  case 0x6F:
6565  case 0x70:
6566  case 0x71:
6567  case 0x72:
6568  case 0x73:
6569  case 0x74:
6570  case 0x75:
6571  case 0x76:
6572  case 0x77:
6573  case 0x78:
6574  case 0x79:
6575  case 0x7A:
6576  case 0x7B:
6577  case 0x7C:
6578  case 0x7D:
6579  case 0x7E:
6580  case 0x7F:
6581  {
6582  add(current);
6583  break;
6584  }
6585 
6586  // U+0080..U+07FF: bytes C2..DF 80..BF
6587  case 0xC2:
6588  case 0xC3:
6589  case 0xC4:
6590  case 0xC5:
6591  case 0xC6:
6592  case 0xC7:
6593  case 0xC8:
6594  case 0xC9:
6595  case 0xCA:
6596  case 0xCB:
6597  case 0xCC:
6598  case 0xCD:
6599  case 0xCE:
6600  case 0xCF:
6601  case 0xD0:
6602  case 0xD1:
6603  case 0xD2:
6604  case 0xD3:
6605  case 0xD4:
6606  case 0xD5:
6607  case 0xD6:
6608  case 0xD7:
6609  case 0xD8:
6610  case 0xD9:
6611  case 0xDA:
6612  case 0xDB:
6613  case 0xDC:
6614  case 0xDD:
6615  case 0xDE:
6616  case 0xDF:
6617  {
6618  if (JSON_HEDLEY_UNLIKELY(!next_byte_in_range({0x80, 0xBF})))
6619  {
6620  return token_type::parse_error;
6621  }
6622  break;
6623  }
6624 
6625  // U+0800..U+0FFF: bytes E0 A0..BF 80..BF
6626  case 0xE0:
6627  {
6628  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0xA0, 0xBF, 0x80, 0xBF}))))
6629  {
6630  return token_type::parse_error;
6631  }
6632  break;
6633  }
6634 
6635  // U+1000..U+CFFF: bytes E1..EC 80..BF 80..BF
6636  // U+E000..U+FFFF: bytes EE..EF 80..BF 80..BF
6637  case 0xE1:
6638  case 0xE2:
6639  case 0xE3:
6640  case 0xE4:
6641  case 0xE5:
6642  case 0xE6:
6643  case 0xE7:
6644  case 0xE8:
6645  case 0xE9:
6646  case 0xEA:
6647  case 0xEB:
6648  case 0xEC:
6649  case 0xEE:
6650  case 0xEF:
6651  {
6652  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF}))))
6653  {
6654  return token_type::parse_error;
6655  }
6656  break;
6657  }
6658 
6659  // U+D000..U+D7FF: bytes ED 80..9F 80..BF
6660  case 0xED:
6661  {
6662  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x9F, 0x80, 0xBF}))))
6663  {
6664  return token_type::parse_error;
6665  }
6666  break;
6667  }
6668 
6669  // U+10000..U+3FFFF F0 90..BF 80..BF 80..BF
6670  case 0xF0:
6671  {
6672  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x90, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
6673  {
6674  return token_type::parse_error;
6675  }
6676  break;
6677  }
6678 
6679  // U+40000..U+FFFFF F1..F3 80..BF 80..BF 80..BF
6680  case 0xF1:
6681  case 0xF2:
6682  case 0xF3:
6683  {
6684  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0xBF, 0x80, 0xBF, 0x80, 0xBF}))))
6685  {
6686  return token_type::parse_error;
6687  }
6688  break;
6689  }
6690 
6691  // U+100000..U+10FFFF F4 80..8F 80..BF 80..BF
6692  case 0xF4:
6693  {
6694  if (JSON_HEDLEY_UNLIKELY(!(next_byte_in_range({0x80, 0x8F, 0x80, 0xBF, 0x80, 0xBF}))))
6695  {
6696  return token_type::parse_error;
6697  }
6698  break;
6699  }
6700 
6701  // remaining bytes (80..C1 and F5..FF) are ill-formed
6702  default:
6703  {
6704  error_message = "invalid string: ill-formed UTF-8 byte";
6705  return token_type::parse_error;
6706  }
6707  }
6708  }
6709  }
6710 
6711  /*!
6712  * @brief scan a comment
6713  * @return whether comment could be scanned successfully
6714  */
6716  {
6717  switch (get())
6718  {
6719  // single-line comments skip input until a newline or EOF is read
6720  case '/':
6721  {
6722  while (true)
6723  {
6724  switch (get())
6725  {
6726  case '\n':
6727  case '\r':
6728  case std::char_traits<char_type>::eof():
6729  case '\0':
6730  return true;
6731 
6732  default:
6733  break;
6734  }
6735  }
6736  }
6737 
6738  // multi-line comments skip input until */ is read
6739  case '*':
6740  {
6741  while (true)
6742  {
6743  switch (get())
6744  {
6745  case std::char_traits<char_type>::eof():
6746  case '\0':
6747  {
6748  error_message = "invalid comment; missing closing '*/'";
6749  return false;
6750  }
6751 
6752  case '*':
6753  {
6754  switch (get())
6755  {
6756  case '/':
6757  return true;
6758 
6759  default:
6760  {
6761  unget();
6762  continue;
6763  }
6764  }
6765  }
6766 
6767  default:
6768  continue;
6769  }
6770  }
6771  }
6772 
6773  // unexpected character after reading '/'
6774  default:
6775  {
6776  error_message = "invalid comment; expecting '/' or '*' after '/'";
6777  return false;
6778  }
6779  }
6780  }
6781 
6782  JSON_HEDLEY_NON_NULL(2)
6783  static void strtof(float& f, const char* str, char** endptr) noexcept
6784  {
6785  f = std::strtof(str, endptr);
6786  }
6787 
6788  JSON_HEDLEY_NON_NULL(2)
6789  static void strtof(double& f, const char* str, char** endptr) noexcept
6790  {
6791  f = std::strtod(str, endptr);
6792  }
6793 
6794  JSON_HEDLEY_NON_NULL(2)
6795  static void strtof(long double& f, const char* str, char** endptr) noexcept
6796  {
6797  f = std::strtold(str, endptr);
6798  }
6799 
6800  /*!
6801  @brief scan a number literal
6802 
6803  This function scans a string according to Sect. 6 of RFC 7159.
6804 
6805  The function is realized with a deterministic finite state machine derived
6806  from the grammar described in RFC 7159. Starting in state "init", the
6807  input is read and used to determined the next state. Only state "done"
6808  accepts the number. State "error" is a trap state to model errors. In the
6809  table below, "anything" means any character but the ones listed before.
6810 
6811  state | 0 | 1-9 | e E | + | - | . | anything
6812  ---------|----------|----------|----------|---------|---------|----------|-----------
6813  init | zero | any1 | [error] | [error] | minus | [error] | [error]
6814  minus | zero | any1 | [error] | [error] | [error] | [error] | [error]
6815  zero | done | done | exponent | done | done | decimal1 | done
6816  any1 | any1 | any1 | exponent | done | done | decimal1 | done
6817  decimal1 | decimal2 | decimal2 | [error] | [error] | [error] | [error] | [error]
6818  decimal2 | decimal2 | decimal2 | exponent | done | done | done | done
6819  exponent | any2 | any2 | [error] | sign | sign | [error] | [error]
6820  sign | any2 | any2 | [error] | [error] | [error] | [error] | [error]
6821  any2 | any2 | any2 | done | done | done | done | done
6822 
6823  The state machine is realized with one label per state (prefixed with
6824  "scan_number_") and `goto` statements between them. The state machine
6825  contains cycles, but any cycle can be left when EOF is read. Therefore,
6826  the function is guaranteed to terminate.
6827 
6828  During scanning, the read bytes are stored in token_buffer. This string is
6829  then converted to a signed integer, an unsigned integer, or a
6830  floating-point number.
6831 
6832  @return token_type::value_unsigned, token_type::value_integer, or
6833  token_type::value_float if number could be successfully scanned,
6834  token_type::parse_error otherwise
6835 
6836  @note The scanner is independent of the current locale. Internally, the
6837  locale's decimal point is used instead of `.` to work with the
6838  locale-dependent converters.
6839  */
6840  token_type scan_number() // lgtm [cpp/use-of-goto]
6841  {
6842  // reset token_buffer to store the number's bytes
6843  reset();
6844 
6845  // the type of the parsed number; initially set to unsigned; will be
6846  // changed if minus sign, decimal point or exponent is read
6847  token_type number_type = token_type::value_unsigned;
6848 
6849  // state (init): we just found out we need to scan a number
6850  switch (current)
6851  {
6852  case '-':
6853  {
6854  add(current);
6855  goto scan_number_minus;
6856  }
6857 
6858  case '0':
6859  {
6860  add(current);
6861  goto scan_number_zero;
6862  }
6863 
6864  case '1':
6865  case '2':
6866  case '3':
6867  case '4':
6868  case '5':
6869  case '6':
6870  case '7':
6871  case '8':
6872  case '9':
6873  {
6874  add(current);
6875  goto scan_number_any1;
6876  }
6877 
6878  // all other characters are rejected outside scan_number()
6879  default: // LCOV_EXCL_LINE
6880  JSON_ASSERT(false); // LCOV_EXCL_LINE
6881  }
6882 
6883 scan_number_minus:
6884  // state: we just parsed a leading minus sign
6885  number_type = token_type::value_integer;
6886  switch (get())
6887  {
6888  case '0':
6889  {
6890  add(current);
6891  goto scan_number_zero;
6892  }
6893 
6894  case '1':
6895  case '2':
6896  case '3':
6897  case '4':
6898  case '5':
6899  case '6':
6900  case '7':
6901  case '8':
6902  case '9':
6903  {
6904  add(current);
6905  goto scan_number_any1;
6906  }
6907 
6908  default:
6909  {
6910  error_message = "invalid number; expected digit after '-'";
6911  return token_type::parse_error;
6912  }
6913  }
6914 
6915 scan_number_zero:
6916  // state: we just parse a zero (maybe with a leading minus sign)
6917  switch (get())
6918  {
6919  case '.':
6920  {
6922  goto scan_number_decimal1;
6923  }
6924 
6925  case 'e':
6926  case 'E':
6927  {
6928  add(current);
6929  goto scan_number_exponent;
6930  }
6931 
6932  default:
6933  goto scan_number_done;
6934  }
6935 
6936 scan_number_any1:
6937  // state: we just parsed a number 0-9 (maybe with a leading minus sign)
6938  switch (get())
6939  {
6940  case '0':
6941  case '1':
6942  case '2':
6943  case '3':
6944  case '4':
6945  case '5':
6946  case '6':
6947  case '7':
6948  case '8':
6949  case '9':
6950  {
6951  add(current);
6952  goto scan_number_any1;
6953  }
6954 
6955  case '.':
6956  {
6958  goto scan_number_decimal1;
6959  }
6960 
6961  case 'e':
6962  case 'E':
6963  {
6964  add(current);
6965  goto scan_number_exponent;
6966  }
6967 
6968  default:
6969  goto scan_number_done;
6970  }
6971 
6972 scan_number_decimal1:
6973  // state: we just parsed a decimal point
6974  number_type = token_type::value_float;
6975  switch (get())
6976  {
6977  case '0':
6978  case '1':
6979  case '2':
6980  case '3':
6981  case '4':
6982  case '5':
6983  case '6':
6984  case '7':
6985  case '8':
6986  case '9':
6987  {
6988  add(current);
6989  goto scan_number_decimal2;
6990  }
6991 
6992  default:
6993  {
6994  error_message = "invalid number; expected digit after '.'";
6995  return token_type::parse_error;
6996  }
6997  }
6998 
6999 scan_number_decimal2:
7000  // we just parsed at least one number after a decimal point
7001  switch (get())
7002  {
7003  case '0':
7004  case '1':
7005  case '2':
7006  case '3':
7007  case '4':
7008  case '5':
7009  case '6':
7010  case '7':
7011  case '8':
7012  case '9':
7013  {
7014  add(current);
7015  goto scan_number_decimal2;
7016  }
7017 
7018  case 'e':
7019  case 'E':
7020  {
7021  add(current);
7022  goto scan_number_exponent;
7023  }
7024 
7025  default:
7026  goto scan_number_done;
7027  }
7028 
7029 scan_number_exponent:
7030  // we just parsed an exponent
7031  number_type = token_type::value_float;
7032  switch (get())
7033  {
7034  case '+':
7035  case '-':
7036  {
7037  add(current);
7038  goto scan_number_sign;
7039  }
7040 
7041  case '0':
7042  case '1':
7043  case '2':
7044  case '3':
7045  case '4':
7046  case '5':
7047  case '6':
7048  case '7':
7049  case '8':
7050  case '9':
7051  {
7052  add(current);
7053  goto scan_number_any2;
7054  }
7055 
7056  default:
7057  {
7058  error_message =
7059  "invalid number; expected '+', '-', or digit after exponent";
7060  return token_type::parse_error;
7061  }
7062  }
7063 
7064 scan_number_sign:
7065  // we just parsed an exponent sign
7066  switch (get())
7067  {
7068  case '0':
7069  case '1':
7070  case '2':
7071  case '3':
7072  case '4':
7073  case '5':
7074  case '6':
7075  case '7':
7076  case '8':
7077  case '9':
7078  {
7079  add(current);
7080  goto scan_number_any2;
7081  }
7082 
7083  default:
7084  {
7085  error_message = "invalid number; expected digit after exponent sign";
7086  return token_type::parse_error;
7087  }
7088  }
7089 
7090 scan_number_any2:
7091  // we just parsed a number after the exponent or exponent sign
7092  switch (get())
7093  {
7094  case '0':
7095  case '1':
7096  case '2':
7097  case '3':
7098  case '4':
7099  case '5':
7100  case '6':
7101  case '7':
7102  case '8':
7103  case '9':
7104  {
7105  add(current);
7106  goto scan_number_any2;
7107  }
7108 
7109  default:
7110  goto scan_number_done;
7111  }
7112 
7113 scan_number_done:
7114  // unget the character after the number (we only read it to know that
7115  // we are done scanning a number)
7116  unget();
7117 
7118  char* endptr = nullptr;
7119  errno = 0;
7120 
7121  // try to parse integers first and fall back to floats
7122  if (number_type == token_type::value_unsigned)
7123  {
7124  const auto x = std::strtoull(token_buffer.data(), &endptr, 10);
7125 
7126  // we checked the number format before
7127  JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7128 
7129  if (errno == 0)
7130  {
7131  value_unsigned = static_cast<number_unsigned_t>(x);
7132  if (value_unsigned == x)
7133  {
7134  return token_type::value_unsigned;
7135  }
7136  }
7137  }
7138  else if (number_type == token_type::value_integer)
7139  {
7140  const auto x = std::strtoll(token_buffer.data(), &endptr, 10);
7141 
7142  // we checked the number format before
7143  JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7144 
7145  if (errno == 0)
7146  {
7147  value_integer = static_cast<number_integer_t>(x);
7148  if (value_integer == x)
7149  {
7150  return token_type::value_integer;
7151  }
7152  }
7153  }
7154 
7155  // this code is reached if we parse a floating-point number or if an
7156  // integer conversion above failed
7157  strtof(value_float, token_buffer.data(), &endptr);
7158 
7159  // we checked the number format before
7160  JSON_ASSERT(endptr == token_buffer.data() + token_buffer.size());
7161 
7162  return token_type::value_float;
7163  }
7164 
7165  /*!
7166  @param[in] literal_text the literal text to expect
7167  @param[in] length the length of the passed literal text
7168  @param[in] return_type the token type to return on success
7169  */
7170  JSON_HEDLEY_NON_NULL(2)
7171  token_type scan_literal(const char_type* literal_text, const std::size_t length,
7172  token_type return_type)
7173  {
7174  JSON_ASSERT(std::char_traits<char_type>::to_char_type(current) == literal_text[0]);
7175  for (std::size_t i = 1; i < length; ++i)
7176  {
7177  if (JSON_HEDLEY_UNLIKELY(std::char_traits<char_type>::to_char_type(get()) != literal_text[i]))
7178  {
7179  error_message = "invalid literal";
7180  return token_type::parse_error;
7181  }
7182  }
7183  return return_type;
7184  }
7185 
7186  /////////////////////
7187  // input management
7188  /////////////////////
7189 
7190  /// reset token_buffer; current character is beginning of token
7191  void reset() noexcept
7192  {
7193  token_buffer.clear();
7194  token_string.clear();
7195  token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7196  }
7197 
7198  /*
7199  @brief get next character from the input
7200 
7201  This function provides the interface to the used input adapter. It does
7202  not throw in case the input reached EOF, but returns a
7203  `std::char_traits<char>::eof()` in that case. Stores the scanned characters
7204  for use in error messages.
7205 
7206  @return character read from the input
7207  */
7208  char_int_type get()
7209  {
7212 
7213  if (next_unget)
7214  {
7215  // just reset the next_unget variable and work with current
7216  next_unget = false;
7217  }
7218  else
7219  {
7220  current = ia.get_character();
7221  }
7222 
7223  if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7224  {
7225  token_string.push_back(std::char_traits<char_type>::to_char_type(current));
7226  }
7227 
7228  if (current == '\n')
7229  {
7230  ++position.lines_read;
7232  }
7233 
7234  return current;
7235  }
7236 
7237  /*!
7238  @brief unget current character (read it again on next get)
7239 
7240  We implement unget by setting variable next_unget to true. The input is not
7241  changed - we just simulate ungetting by modifying chars_read_total,
7242  chars_read_current_line, and token_string. The next call to get() will
7243  behave as if the unget character is read again.
7244  */
7245  void unget()
7246  {
7247  next_unget = true;
7248 
7250 
7251  // in case we "unget" a newline, we have to also decrement the lines_read
7253  {
7254  if (position.lines_read > 0)
7255  {
7256  --position.lines_read;
7257  }
7258  }
7259  else
7260  {
7262  }
7263 
7264  if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
7265  {
7266  JSON_ASSERT(!token_string.empty());
7267  token_string.pop_back();
7268  }
7269  }
7270 
7271  /// add a character to token_buffer
7272  void add(char_int_type c)
7273  {
7274  token_buffer.push_back(static_cast<typename string_t::value_type>(c));
7275  }
7276 
7277  public:
7278  /////////////////////
7279  // value getters
7280  /////////////////////
7281 
7282  /// return integer value
7283  constexpr number_integer_t get_number_integer() const noexcept
7284  {
7285  return value_integer;
7286  }
7287 
7288  /// return unsigned integer value
7289  constexpr number_unsigned_t get_number_unsigned() const noexcept
7290  {
7291  return value_unsigned;
7292  }
7293 
7294  /// return floating-point value
7295  constexpr number_float_t get_number_float() const noexcept
7296  {
7297  return value_float;
7298  }
7299 
7300  /// return current string value (implicitly resets the token; useful only once)
7301  string_t& get_string()
7302  {
7303  return token_buffer;
7304  }
7305 
7306  /////////////////////
7307  // diagnostics
7308  /////////////////////
7309 
7310  /// return position of last read token
7311  constexpr position_t get_position() const noexcept
7312  {
7313  return position;
7314  }
7315 
7316  /// return the last read token (for errors only). Will never contain EOF
7317  /// (an arbitrary value that is not a valid char value, often -1), because
7318  /// 255 may legitimately occur. May contain NUL, which should be escaped.
7319  std::string get_token_string() const
7320  {
7321  // escape control characters
7322  std::string result;
7323  for (const auto c : token_string)
7324  {
7325  if (static_cast<unsigned char>(c) <= '\x1F')
7326  {
7327  // escape control characters
7328  std::array<char, 9> cs{{}};
7329  (std::snprintf)(cs.data(), cs.size(), "<U+%.4X>", static_cast<unsigned char>(c));
7330  result += cs.data();
7331  }
7332  else
7333  {
7334  // add character as is
7335  result.push_back(static_cast<std::string::value_type>(c));
7336  }
7337  }
7338 
7339  return result;
7340  }
7341 
7342  /// return syntax error message
7343  JSON_HEDLEY_RETURNS_NON_NULL
7344  constexpr const char* get_error_message() const noexcept
7345  {
7346  return error_message;
7347  }
7348 
7349  /////////////////////
7350  // actual scanner
7351  /////////////////////
7352 
7353  /*!
7354  @brief skip the UTF-8 byte order mark
7355  @return true iff there is no BOM or the correct BOM has been skipped
7356  */
7357  bool skip_bom()
7358  {
7359  if (get() == 0xEF)
7360  {
7361  // check if we completely parse the BOM
7362  return get() == 0xBB && get() == 0xBF;
7363  }
7364 
7365  // the first character is not the beginning of the BOM; unget it to
7366  // process is later
7367  unget();
7368  return true;
7369  }
7370 
7371  void skip_whitespace()
7372  {
7373  do
7374  {
7375  get();
7376  }
7377  while (current == ' ' || current == '\t' || current == '\n' || current == '\r');
7378  }
7379 
7380  token_type scan()
7381  {
7382  // initially, skip the BOM
7383  if (position.chars_read_total == 0 && !skip_bom())
7384  {
7385  error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
7386  return token_type::parse_error;
7387  }
7388 
7389  // read next character and ignore whitespace
7390  skip_whitespace();
7391 
7392  // ignore comments
7393  while (ignore_comments && current == '/')
7394  {
7395  if (!scan_comment())
7396  {
7397  return token_type::parse_error;
7398  }
7399 
7400  // skip following whitespace
7401  skip_whitespace();
7402  }
7403 
7404  switch (current)
7405  {
7406  // structural characters
7407  case '[':
7408  return token_type::begin_array;
7409  case ']':
7410  return token_type::end_array;
7411  case '{':
7412  return token_type::begin_object;
7413  case '}':
7414  return token_type::end_object;
7415  case ':':
7416  return token_type::name_separator;
7417  case ',':
7418  return token_type::value_separator;
7419 
7420  // literals
7421  case 't':
7422  {
7423  std::array<char_type, 4> true_literal = {{'t', 'r', 'u', 'e'}};
7424  return scan_literal(true_literal.data(), true_literal.size(), token_type::literal_true);
7425  }
7426  case 'f':
7427  {
7428  std::array<char_type, 5> false_literal = {{'f', 'a', 'l', 's', 'e'}};
7429  return scan_literal(false_literal.data(), false_literal.size(), token_type::literal_false);
7430  }
7431  case 'n':
7432  {
7433  std::array<char_type, 4> null_literal = {{'n', 'u', 'l', 'l'}};
7434  return scan_literal(null_literal.data(), null_literal.size(), token_type::literal_null);
7435  }
7436 
7437  // string
7438  case '\"':
7439  return scan_string();
7440 
7441  // number
7442  case '-':
7443  case '0':
7444  case '1':
7445  case '2':
7446  case '3':
7447  case '4':
7448  case '5':
7449  case '6':
7450  case '7':
7451  case '8':
7452  case '9':
7453  return scan_number();
7454 
7455  // end of input (the null byte is needed when parsing from
7456  // string literals)
7457  case '\0':
7458  case std::char_traits<char_type>::eof():
7459  return token_type::end_of_input;
7460 
7461  // error
7462  default:
7463  error_message = "invalid literal";
7464  return token_type::parse_error;
7465  }
7466  }
7467 
7468  private:
7469  /// input adapter
7470  InputAdapterType ia;
7471 
7472  /// whether comments should be ignored (true) or signaled as errors (false)
7473  const bool ignore_comments = false;
7474 
7475  /// the current character
7476  char_int_type current = std::char_traits<char_type>::eof();
7477 
7478  /// whether the next get() call should just return current
7479  bool next_unget = false;
7480 
7481  /// the start position of the current token
7483 
7484  /// raw input token string (for error messages)
7485  std::vector<char_type> token_string {};
7486 
7487  /// buffer for variable-length tokens (numbers, strings)
7488  string_t token_buffer {};
7489 
7490  /// a description of occurred lexer errors
7491  const char* error_message = "";
7492 
7493  // number values
7494  number_integer_t value_integer = 0;
7495  number_unsigned_t value_unsigned = 0;
7496  number_float_t value_float = 0;
7497 
7498  /// the decimal point
7499  const char_int_type decimal_point_char = '.';
7500 };
7501 } // namespace detail
7502 } // namespace nlohmann
7503 
7504 // #include <nlohmann/detail/macro_scope.hpp>
7505 
7506 // #include <nlohmann/detail/meta/is_sax.hpp>
7507 
7508 
7509 #include <cstdint> // size_t
7510 #include <utility> // declval
7511 #include <string> // string
7512 
7513 // #include <nlohmann/detail/meta/detected.hpp>
7514 
7515 // #include <nlohmann/detail/meta/type_traits.hpp>
7516 
7517 
7518 namespace nlohmann
7519 {
7520 namespace detail
7521 {
7522 template<typename T>
7523 using null_function_t = decltype(std::declval<T&>().null());
7524 
7525 template<typename T>
7526 using boolean_function_t =
7527  decltype(std::declval<T&>().boolean(std::declval<bool>()));
7528 
7529 template<typename T, typename Integer>
7530 using number_integer_function_t =
7531  decltype(std::declval<T&>().number_integer(std::declval<Integer>()));
7532 
7533 template<typename T, typename Unsigned>
7534 using number_unsigned_function_t =
7535  decltype(std::declval<T&>().number_unsigned(std::declval<Unsigned>()));
7536 
7537 template<typename T, typename Float, typename String>
7538 using number_float_function_t = decltype(std::declval<T&>().number_float(
7539  std::declval<Float>(), std::declval<const String&>()));
7540 
7541 template<typename T, typename String>
7542 using string_function_t =
7543  decltype(std::declval<T&>().string(std::declval<String&>()));
7544 
7545 template<typename T, typename Binary>
7546 using binary_function_t =
7547  decltype(std::declval<T&>().binary(std::declval<Binary&>()));
7548 
7549 template<typename T>
7550 using start_object_function_t =
7551  decltype(std::declval<T&>().start_object(std::declval<std::size_t>()));
7552 
7553 template<typename T, typename String>
7554 using key_function_t =
7555  decltype(std::declval<T&>().key(std::declval<String&>()));
7556 
7557 template<typename T>
7558 using end_object_function_t = decltype(std::declval<T&>().end_object());
7559 
7560 template<typename T>
7561 using start_array_function_t =
7562  decltype(std::declval<T&>().start_array(std::declval<std::size_t>()));
7563 
7564 template<typename T>
7565 using end_array_function_t = decltype(std::declval<T&>().end_array());
7566 
7567 template<typename T, typename Exception>
7568 using parse_error_function_t = decltype(std::declval<T&>().parse_error(
7569  std::declval<std::size_t>(), std::declval<const std::string&>(),
7570  std::declval<const Exception&>()));
7571 
7572 template<typename SAX, typename BasicJsonType>
7573 struct is_sax
7574 {
7575  private:
7577  "BasicJsonType must be of type basic_json<...>");
7578 
7579  using number_integer_t = typename BasicJsonType::number_integer_t;
7580  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
7581  using number_float_t = typename BasicJsonType::number_float_t;
7582  using string_t = typename BasicJsonType::string_t;
7583  using binary_t = typename BasicJsonType::binary_t;
7584  using exception_t = typename BasicJsonType::exception;
7585 
7586  public:
7587  static constexpr bool value =
7588  is_detected_exact<bool, null_function_t, SAX>::value &&
7589  is_detected_exact<bool, boolean_function_t, SAX>::value &&
7590  is_detected_exact<bool, number_integer_function_t, SAX, number_integer_t>::value &&
7591  is_detected_exact<bool, number_unsigned_function_t, SAX, number_unsigned_t>::value &&
7592  is_detected_exact<bool, number_float_function_t, SAX, number_float_t, string_t>::value &&
7593  is_detected_exact<bool, string_function_t, SAX, string_t>::value &&
7594  is_detected_exact<bool, binary_function_t, SAX, binary_t>::value &&
7595  is_detected_exact<bool, start_object_function_t, SAX>::value &&
7596  is_detected_exact<bool, key_function_t, SAX, string_t>::value &&
7597  is_detected_exact<bool, end_object_function_t, SAX>::value &&
7598  is_detected_exact<bool, start_array_function_t, SAX>::value &&
7599  is_detected_exact<bool, end_array_function_t, SAX>::value &&
7600  is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value;
7601 };
7602 
7603 template<typename SAX, typename BasicJsonType>
7605 {
7606  private:
7608  "BasicJsonType must be of type basic_json<...>");
7609 
7610  using number_integer_t = typename BasicJsonType::number_integer_t;
7611  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
7612  using number_float_t = typename BasicJsonType::number_float_t;
7613  using string_t = typename BasicJsonType::string_t;
7614  using binary_t = typename BasicJsonType::binary_t;
7615  using exception_t = typename BasicJsonType::exception;
7616 
7617  public:
7618  static_assert(is_detected_exact<bool, null_function_t, SAX>::value,
7619  "Missing/invalid function: bool null()");
7620  static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
7621  "Missing/invalid function: bool boolean(bool)");
7622  static_assert(is_detected_exact<bool, boolean_function_t, SAX>::value,
7623  "Missing/invalid function: bool boolean(bool)");
7624  static_assert(
7625  is_detected_exact<bool, number_integer_function_t, SAX,
7626  number_integer_t>::value,
7627  "Missing/invalid function: bool number_integer(number_integer_t)");
7628  static_assert(
7629  is_detected_exact<bool, number_unsigned_function_t, SAX,
7630  number_unsigned_t>::value,
7631  "Missing/invalid function: bool number_unsigned(number_unsigned_t)");
7632  static_assert(is_detected_exact<bool, number_float_function_t, SAX,
7633  number_float_t, string_t>::value,
7634  "Missing/invalid function: bool number_float(number_float_t, const string_t&)");
7635  static_assert(
7636  is_detected_exact<bool, string_function_t, SAX, string_t>::value,
7637  "Missing/invalid function: bool string(string_t&)");
7638  static_assert(
7639  is_detected_exact<bool, binary_function_t, SAX, binary_t>::value,
7640  "Missing/invalid function: bool binary(binary_t&)");
7641  static_assert(is_detected_exact<bool, start_object_function_t, SAX>::value,
7642  "Missing/invalid function: bool start_object(std::size_t)");
7643  static_assert(is_detected_exact<bool, key_function_t, SAX, string_t>::value,
7644  "Missing/invalid function: bool key(string_t&)");
7645  static_assert(is_detected_exact<bool, end_object_function_t, SAX>::value,
7646  "Missing/invalid function: bool end_object()");
7647  static_assert(is_detected_exact<bool, start_array_function_t, SAX>::value,
7648  "Missing/invalid function: bool start_array(std::size_t)");
7649  static_assert(is_detected_exact<bool, end_array_function_t, SAX>::value,
7650  "Missing/invalid function: bool end_array()");
7651  static_assert(
7652  is_detected_exact<bool, parse_error_function_t, SAX, exception_t>::value,
7653  "Missing/invalid function: bool parse_error(std::size_t, const "
7654  "std::string&, const exception&)");
7655 };
7656 } // namespace detail
7657 } // namespace nlohmann
7658 
7659 // #include <nlohmann/detail/value_t.hpp>
7660 
7661 
7662 namespace nlohmann
7663 {
7664 namespace detail
7665 {
7666 
7667 /// how to treat CBOR tags
7669 {
7670  error, ///< throw a parse_error exception in case of a tag
7671  ignore ///< ignore tags
7672 };
7673 
7674 /*!
7675 @brief determine system byte order
7676 
7677 @return true if and only if system's byte order is little endian
7678 
7679 @note from https://stackoverflow.com/a/1001328/266378
7680 */
7681 static inline bool little_endianess(int num = 1) noexcept
7682 {
7683  return *reinterpret_cast<char*>(&num) == 1;
7684 }
7685 
7686 
7687 ///////////////////
7688 // binary reader //
7689 ///////////////////
7690 
7691 /*!
7692 @brief deserialization of CBOR, MessagePack, and UBJSON values
7693 */
7694 template<typename BasicJsonType, typename InputAdapterType, typename SAX = json_sax_dom_parser<BasicJsonType>>
7696 {
7697  using number_integer_t = typename BasicJsonType::number_integer_t;
7698  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
7699  using number_float_t = typename BasicJsonType::number_float_t;
7700  using string_t = typename BasicJsonType::string_t;
7701  using binary_t = typename BasicJsonType::binary_t;
7702  using json_sax_t = SAX;
7703  using char_type = typename InputAdapterType::char_type;
7704  using char_int_type = typename std::char_traits<char_type>::int_type;
7705 
7706  public:
7707  /*!
7708  @brief create a binary reader
7709 
7710  @param[in] adapter input adapter to read from
7711  */
7712  explicit binary_reader(InputAdapterType&& adapter) : ia(std::move(adapter))
7713  {
7715  }
7716 
7717  // make class move-only
7718  binary_reader(const binary_reader&) = delete;
7719  binary_reader(binary_reader&&) = default;
7720  binary_reader& operator=(const binary_reader&) = delete;
7721  binary_reader& operator=(binary_reader&&) = default;
7722  ~binary_reader() = default;
7723 
7724  /*!
7725  @param[in] format the binary format to parse
7726  @param[in] sax_ a SAX event processor
7727  @param[in] strict whether to expect the input to be consumed completed
7728  @param[in] tag_handler how to treat CBOR tags
7729 
7730  @return
7731  */
7732  JSON_HEDLEY_NON_NULL(3)
7733  bool sax_parse(const input_format_t format,
7734  json_sax_t* sax_,
7735  const bool strict = true,
7736  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
7737  {
7738  sax = sax_;
7739  bool result = false;
7740 
7741  switch (format)
7742  {
7743  case input_format_t::bson:
7744  result = parse_bson_internal();
7745  break;
7746 
7747  case input_format_t::cbor:
7748  result = parse_cbor_internal(true, tag_handler);
7749  break;
7750 
7751  case input_format_t::msgpack:
7752  result = parse_msgpack_internal();
7753  break;
7754 
7755  case input_format_t::ubjson:
7756  result = parse_ubjson_internal();
7757  break;
7758 
7759  default: // LCOV_EXCL_LINE
7760  JSON_ASSERT(false); // LCOV_EXCL_LINE
7761  }
7762 
7763  // strict mode: next byte must be EOF
7764  if (result && strict)
7765  {
7766  if (format == input_format_t::ubjson)
7767  {
7768  get_ignore_noop();
7769  }
7770  else
7771  {
7772  get();
7773  }
7774 
7775  if (JSON_HEDLEY_UNLIKELY(current != std::char_traits<char_type>::eof()))
7776  {
7777  return sax->parse_error(chars_read, get_token_string(),
7778  parse_error::create(110, chars_read, exception_message(format, "expected end of input; last byte: 0x" + get_token_string(), "value")));
7779  }
7780  }
7781 
7782  return result;
7783  }
7784 
7785  private:
7786  //////////
7787  // BSON //
7788  //////////
7789 
7790  /*!
7791  @brief Reads in a BSON-object and passes it to the SAX-parser.
7792  @return whether a valid BSON-value was passed to the SAX parser
7793  */
7795  {
7796  std::int32_t document_size{};
7797  get_number<std::int32_t, true>(input_format_t::bson, document_size);
7798 
7799  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
7800  {
7801  return false;
7802  }
7803 
7804  if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/false)))
7805  {
7806  return false;
7807  }
7808 
7809  return sax->end_object();
7810  }
7811 
7812  /*!
7813  @brief Parses a C-style string from the BSON input.
7814  @param[in, out] result A reference to the string variable where the read
7815  string is to be stored.
7816  @return `true` if the \x00-byte indicating the end of the string was
7817  encountered before the EOF; false` indicates an unexpected EOF.
7818  */
7819  bool get_bson_cstr(string_t& result)
7820  {
7821  auto out = std::back_inserter(result);
7822  while (true)
7823  {
7824  get();
7825  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "cstring")))
7826  {
7827  return false;
7828  }
7829  if (current == 0x00)
7830  {
7831  return true;
7832  }
7833  *out++ = static_cast<typename string_t::value_type>(current);
7834  }
7835  }
7836 
7837  /*!
7838  @brief Parses a zero-terminated string of length @a len from the BSON
7839  input.
7840  @param[in] len The length (including the zero-byte at the end) of the
7841  string to be read.
7842  @param[in, out] result A reference to the string variable where the read
7843  string is to be stored.
7844  @tparam NumberType The type of the length @a len
7845  @pre len >= 1
7846  @return `true` if the string was successfully parsed
7847  */
7848  template<typename NumberType>
7849  bool get_bson_string(const NumberType len, string_t& result)
7850  {
7851  if (JSON_HEDLEY_UNLIKELY(len < 1))
7852  {
7853  auto last_token = get_token_string();
7854  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "string length must be at least 1, is " + std::to_string(len), "string")));
7855  }
7856 
7857  return get_string(input_format_t::bson, len - static_cast<NumberType>(1), result) && get() != std::char_traits<char_type>::eof();
7858  }
7859 
7860  /*!
7861  @brief Parses a byte array input of length @a len from the BSON input.
7862  @param[in] len The length of the byte array to be read.
7863  @param[in, out] result A reference to the binary variable where the read
7864  array is to be stored.
7865  @tparam NumberType The type of the length @a len
7866  @pre len >= 0
7867  @return `true` if the byte array was successfully parsed
7868  */
7869  template<typename NumberType>
7870  bool get_bson_binary(const NumberType len, binary_t& result)
7871  {
7872  if (JSON_HEDLEY_UNLIKELY(len < 0))
7873  {
7874  auto last_token = get_token_string();
7875  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::bson, "byte array length cannot be negative, is " + std::to_string(len), "binary")));
7876  }
7877 
7878  // All BSON binary values have a subtype
7879  std::uint8_t subtype{};
7880  get_number<std::uint8_t>(input_format_t::bson, subtype);
7881  result.set_subtype(subtype);
7882 
7883  return get_binary(input_format_t::bson, len, result);
7884  }
7885 
7886  /*!
7887  @brief Read a BSON document element of the given @a element_type.
7888  @param[in] element_type The BSON element type, c.f. http://bsonspec.org/spec.html
7889  @param[in] element_type_parse_position The position in the input stream,
7890  where the `element_type` was read.
7891  @warning Not all BSON element types are supported yet. An unsupported
7892  @a element_type will give rise to a parse_error.114:
7893  Unsupported BSON record type 0x...
7894  @return whether a valid BSON-object/array was passed to the SAX parser
7895  */
7896  bool parse_bson_element_internal(const char_int_type element_type,
7897  const std::size_t element_type_parse_position)
7898  {
7899  switch (element_type)
7900  {
7901  case 0x01: // double
7902  {
7903  double number{};
7904  return get_number<double, true>(input_format_t::bson, number) && sax->number_float(static_cast<number_float_t>(number), "");
7905  }
7906 
7907  case 0x02: // string
7908  {
7909  std::int32_t len{};
7910  string_t value;
7911  return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_string(len, value) && sax->string(value);
7912  }
7913 
7914  case 0x03: // object
7915  {
7916  return parse_bson_internal();
7917  }
7918 
7919  case 0x04: // array
7920  {
7921  return parse_bson_array();
7922  }
7923 
7924  case 0x05: // binary
7925  {
7926  std::int32_t len{};
7927  binary_t value;
7928  return get_number<std::int32_t, true>(input_format_t::bson, len) && get_bson_binary(len, value) && sax->binary(value);
7929  }
7930 
7931  case 0x08: // boolean
7932  {
7933  return sax->boolean(get() != 0);
7934  }
7935 
7936  case 0x0A: // null
7937  {
7938  return sax->null();
7939  }
7940 
7941  case 0x10: // int32
7942  {
7943  std::int32_t value{};
7944  return get_number<std::int32_t, true>(input_format_t::bson, value) && sax->number_integer(value);
7945  }
7946 
7947  case 0x12: // int64
7948  {
7949  std::int64_t value{};
7950  return get_number<std::int64_t, true>(input_format_t::bson, value) && sax->number_integer(value);
7951  }
7952 
7953  default: // anything else not supported (yet)
7954  {
7955  std::array<char, 3> cr{{}};
7956  (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(element_type));
7957  return sax->parse_error(element_type_parse_position, std::string(cr.data()), parse_error::create(114, element_type_parse_position, "Unsupported BSON record type 0x" + std::string(cr.data())));
7958  }
7959  }
7960  }
7961 
7962  /*!
7963  @brief Read a BSON element list (as specified in the BSON-spec)
7964 
7965  The same binary layout is used for objects and arrays, hence it must be
7966  indicated with the argument @a is_array which one is expected
7967  (true --> array, false --> object).
7968 
7969  @param[in] is_array Determines if the element list being read is to be
7970  treated as an object (@a is_array == false), or as an
7971  array (@a is_array == true).
7972  @return whether a valid BSON-object/array was passed to the SAX parser
7973  */
7974  bool parse_bson_element_list(const bool is_array)
7975  {
7976  string_t key;
7977 
7978  while (auto element_type = get())
7979  {
7980  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::bson, "element list")))
7981  {
7982  return false;
7983  }
7984 
7985  const std::size_t element_type_parse_position = chars_read;
7986  if (JSON_HEDLEY_UNLIKELY(!get_bson_cstr(key)))
7987  {
7988  return false;
7989  }
7990 
7991  if (!is_array && !sax->key(key))
7992  {
7993  return false;
7994  }
7995 
7996  if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_internal(element_type, element_type_parse_position)))
7997  {
7998  return false;
7999  }
8000 
8001  // get_bson_cstr only appends
8002  key.clear();
8003  }
8004 
8005  return true;
8006  }
8007 
8008  /*!
8009  @brief Reads an array from the BSON input and passes it to the SAX-parser.
8010  @return whether a valid BSON-array was passed to the SAX parser
8011  */
8013  {
8014  std::int32_t document_size{};
8015  get_number<std::int32_t, true>(input_format_t::bson, document_size);
8016 
8017  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
8018  {
8019  return false;
8020  }
8021 
8022  if (JSON_HEDLEY_UNLIKELY(!parse_bson_element_list(/*is_array*/true)))
8023  {
8024  return false;
8025  }
8026 
8027  return sax->end_array();
8028  }
8029 
8030  //////////
8031  // CBOR //
8032  //////////
8033 
8034  /*!
8035  @param[in] get_char whether a new character should be retrieved from the
8036  input (true) or whether the last read character should
8037  be considered instead (false)
8038  @param[in] tag_handler how CBOR tags should be treated
8039 
8040  @return whether a valid CBOR value was passed to the SAX parser
8041  */
8042  bool parse_cbor_internal(const bool get_char,
8043  const cbor_tag_handler_t tag_handler)
8044  {
8045  switch (get_char ? get() : current)
8046  {
8047  // EOF
8048  case std::char_traits<char_type>::eof():
8049  return unexpect_eof(input_format_t::cbor, "value");
8050 
8051  // Integer 0x00..0x17 (0..23)
8052  case 0x00:
8053  case 0x01:
8054  case 0x02:
8055  case 0x03:
8056  case 0x04:
8057  case 0x05:
8058  case 0x06:
8059  case 0x07:
8060  case 0x08:
8061  case 0x09:
8062  case 0x0A:
8063  case 0x0B:
8064  case 0x0C:
8065  case 0x0D:
8066  case 0x0E:
8067  case 0x0F:
8068  case 0x10:
8069  case 0x11:
8070  case 0x12:
8071  case 0x13:
8072  case 0x14:
8073  case 0x15:
8074  case 0x16:
8075  case 0x17:
8076  return sax->number_unsigned(static_cast<number_unsigned_t>(current));
8077 
8078  case 0x18: // Unsigned integer (one-byte uint8_t follows)
8079  {
8080  std::uint8_t number{};
8081  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8082  }
8083 
8084  case 0x19: // Unsigned integer (two-byte uint16_t follows)
8085  {
8086  std::uint16_t number{};
8087  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8088  }
8089 
8090  case 0x1A: // Unsigned integer (four-byte uint32_t follows)
8091  {
8092  std::uint32_t number{};
8093  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8094  }
8095 
8096  case 0x1B: // Unsigned integer (eight-byte uint64_t follows)
8097  {
8098  std::uint64_t number{};
8099  return get_number(input_format_t::cbor, number) && sax->number_unsigned(number);
8100  }
8101 
8102  // Negative integer -1-0x00..-1-0x17 (-1..-24)
8103  case 0x20:
8104  case 0x21:
8105  case 0x22:
8106  case 0x23:
8107  case 0x24:
8108  case 0x25:
8109  case 0x26:
8110  case 0x27:
8111  case 0x28:
8112  case 0x29:
8113  case 0x2A:
8114  case 0x2B:
8115  case 0x2C:
8116  case 0x2D:
8117  case 0x2E:
8118  case 0x2F:
8119  case 0x30:
8120  case 0x31:
8121  case 0x32:
8122  case 0x33:
8123  case 0x34:
8124  case 0x35:
8125  case 0x36:
8126  case 0x37:
8127  return sax->number_integer(static_cast<std::int8_t>(0x20 - 1 - current));
8128 
8129  case 0x38: // Negative integer (one-byte uint8_t follows)
8130  {
8131  std::uint8_t number{};
8132  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8133  }
8134 
8135  case 0x39: // Negative integer -1-n (two-byte uint16_t follows)
8136  {
8137  std::uint16_t number{};
8138  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8139  }
8140 
8141  case 0x3A: // Negative integer -1-n (four-byte uint32_t follows)
8142  {
8143  std::uint32_t number{};
8144  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1) - number);
8145  }
8146 
8147  case 0x3B: // Negative integer -1-n (eight-byte uint64_t follows)
8148  {
8149  std::uint64_t number{};
8150  return get_number(input_format_t::cbor, number) && sax->number_integer(static_cast<number_integer_t>(-1)
8151  - static_cast<number_integer_t>(number));
8152  }
8153 
8154  // Binary data (0x00..0x17 bytes follow)
8155  case 0x40:
8156  case 0x41:
8157  case 0x42:
8158  case 0x43:
8159  case 0x44:
8160  case 0x45:
8161  case 0x46:
8162  case 0x47:
8163  case 0x48:
8164  case 0x49:
8165  case 0x4A:
8166  case 0x4B:
8167  case 0x4C:
8168  case 0x4D:
8169  case 0x4E:
8170  case 0x4F:
8171  case 0x50:
8172  case 0x51:
8173  case 0x52:
8174  case 0x53:
8175  case 0x54:
8176  case 0x55:
8177  case 0x56:
8178  case 0x57:
8179  case 0x58: // Binary data (one-byte uint8_t for n follows)
8180  case 0x59: // Binary data (two-byte uint16_t for n follow)
8181  case 0x5A: // Binary data (four-byte uint32_t for n follow)
8182  case 0x5B: // Binary data (eight-byte uint64_t for n follow)
8183  case 0x5F: // Binary data (indefinite length)
8184  {
8185  binary_t b;
8186  return get_cbor_binary(b) && sax->binary(b);
8187  }
8188 
8189  // UTF-8 string (0x00..0x17 bytes follow)
8190  case 0x60:
8191  case 0x61:
8192  case 0x62:
8193  case 0x63:
8194  case 0x64:
8195  case 0x65:
8196  case 0x66:
8197  case 0x67:
8198  case 0x68:
8199  case 0x69:
8200  case 0x6A:
8201  case 0x6B:
8202  case 0x6C:
8203  case 0x6D:
8204  case 0x6E:
8205  case 0x6F:
8206  case 0x70:
8207  case 0x71:
8208  case 0x72:
8209  case 0x73:
8210  case 0x74:
8211  case 0x75:
8212  case 0x76:
8213  case 0x77:
8214  case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
8215  case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
8216  case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
8217  case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
8218  case 0x7F: // UTF-8 string (indefinite length)
8219  {
8220  string_t s;
8221  return get_cbor_string(s) && sax->string(s);
8222  }
8223 
8224  // array (0x00..0x17 data items follow)
8225  case 0x80:
8226  case 0x81:
8227  case 0x82:
8228  case 0x83:
8229  case 0x84:
8230  case 0x85:
8231  case 0x86:
8232  case 0x87:
8233  case 0x88:
8234  case 0x89:
8235  case 0x8A:
8236  case 0x8B:
8237  case 0x8C:
8238  case 0x8D:
8239  case 0x8E:
8240  case 0x8F:
8241  case 0x90:
8242  case 0x91:
8243  case 0x92:
8244  case 0x93:
8245  case 0x94:
8246  case 0x95:
8247  case 0x96:
8248  case 0x97:
8249  return get_cbor_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8250 
8251  case 0x98: // array (one-byte uint8_t for n follows)
8252  {
8253  std::uint8_t len{};
8254  return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8255  }
8256 
8257  case 0x99: // array (two-byte uint16_t for n follow)
8258  {
8259  std::uint16_t len{};
8260  return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8261  }
8262 
8263  case 0x9A: // array (four-byte uint32_t for n follow)
8264  {
8265  std::uint32_t len{};
8266  return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8267  }
8268 
8269  case 0x9B: // array (eight-byte uint64_t for n follow)
8270  {
8271  std::uint64_t len{};
8272  return get_number(input_format_t::cbor, len) && get_cbor_array(static_cast<std::size_t>(len), tag_handler);
8273  }
8274 
8275  case 0x9F: // array (indefinite length)
8276  return get_cbor_array(std::size_t(-1), tag_handler);
8277 
8278  // map (0x00..0x17 pairs of data items follow)
8279  case 0xA0:
8280  case 0xA1:
8281  case 0xA2:
8282  case 0xA3:
8283  case 0xA4:
8284  case 0xA5:
8285  case 0xA6:
8286  case 0xA7:
8287  case 0xA8:
8288  case 0xA9:
8289  case 0xAA:
8290  case 0xAB:
8291  case 0xAC:
8292  case 0xAD:
8293  case 0xAE:
8294  case 0xAF:
8295  case 0xB0:
8296  case 0xB1:
8297  case 0xB2:
8298  case 0xB3:
8299  case 0xB4:
8300  case 0xB5:
8301  case 0xB6:
8302  case 0xB7:
8303  return get_cbor_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x1Fu), tag_handler);
8304 
8305  case 0xB8: // map (one-byte uint8_t for n follows)
8306  {
8307  std::uint8_t len{};
8308  return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8309  }
8310 
8311  case 0xB9: // map (two-byte uint16_t for n follow)
8312  {
8313  std::uint16_t len{};
8314  return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8315  }
8316 
8317  case 0xBA: // map (four-byte uint32_t for n follow)
8318  {
8319  std::uint32_t len{};
8320  return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8321  }
8322 
8323  case 0xBB: // map (eight-byte uint64_t for n follow)
8324  {
8325  std::uint64_t len{};
8326  return get_number(input_format_t::cbor, len) && get_cbor_object(static_cast<std::size_t>(len), tag_handler);
8327  }
8328 
8329  case 0xBF: // map (indefinite length)
8330  return get_cbor_object(std::size_t(-1), tag_handler);
8331 
8332  case 0xC6: // tagged item
8333  case 0xC7:
8334  case 0xC8:
8335  case 0xC9:
8336  case 0xCA:
8337  case 0xCB:
8338  case 0xCC:
8339  case 0xCD:
8340  case 0xCE:
8341  case 0xCF:
8342  case 0xD0:
8343  case 0xD1:
8344  case 0xD2:
8345  case 0xD3:
8346  case 0xD4:
8347  case 0xD8: // tagged item (1 bytes follow)
8348  case 0xD9: // tagged item (2 bytes follow)
8349  case 0xDA: // tagged item (4 bytes follow)
8350  case 0xDB: // tagged item (8 bytes follow)
8351  {
8352  switch (tag_handler)
8353  {
8355  {
8356  auto last_token = get_token_string();
8357  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
8358  }
8359 
8361  {
8362  switch (current)
8363  {
8364  case 0xD8:
8365  {
8366  std::uint8_t len{};
8367  get_number(input_format_t::cbor, len);
8368  break;
8369  }
8370  case 0xD9:
8371  {
8372  std::uint16_t len{};
8373  get_number(input_format_t::cbor, len);
8374  break;
8375  }
8376  case 0xDA:
8377  {
8378  std::uint32_t len{};
8379  get_number(input_format_t::cbor, len);
8380  break;
8381  }
8382  case 0xDB:
8383  {
8384  std::uint64_t len{};
8385  get_number(input_format_t::cbor, len);
8386  break;
8387  }
8388  default:
8389  break;
8390  }
8391  return parse_cbor_internal(true, tag_handler);
8392  }
8393 
8394  default: // LCOV_EXCL_LINE
8395  JSON_ASSERT(false); // LCOV_EXCL_LINE
8396  }
8397  }
8398 
8399  case 0xF4: // false
8400  return sax->boolean(false);
8401 
8402  case 0xF5: // true
8403  return sax->boolean(true);
8404 
8405  case 0xF6: // null
8406  return sax->null();
8407 
8408  case 0xF9: // Half-Precision Float (two-byte IEEE 754)
8409  {
8410  const auto byte1_raw = get();
8411  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
8412  {
8413  return false;
8414  }
8415  const auto byte2_raw = get();
8416  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "number")))
8417  {
8418  return false;
8419  }
8420 
8421  const auto byte1 = static_cast<unsigned char>(byte1_raw);
8422  const auto byte2 = static_cast<unsigned char>(byte2_raw);
8423 
8424  // code from RFC 7049, Appendix D, Figure 3:
8425  // As half-precision floating-point numbers were only added
8426  // to IEEE 754 in 2008, today's programming platforms often
8427  // still only have limited support for them. It is very
8428  // easy to include at least decoding support for them even
8429  // without such support. An example of a small decoder for
8430  // half-precision floating-point numbers in the C language
8431  // is shown in Fig. 3.
8432  const auto half = static_cast<unsigned int>((byte1 << 8u) + byte2);
8433  const double val = [&half]
8434  {
8435  const int exp = (half >> 10u) & 0x1Fu;
8436  const unsigned int mant = half & 0x3FFu;
8437  JSON_ASSERT(0 <= exp&& exp <= 32);
8438  JSON_ASSERT(mant <= 1024);
8439  switch (exp)
8440  {
8441  case 0:
8442  return std::ldexp(mant, -24);
8443  case 31:
8444  return (mant == 0)
8445  ? std::numeric_limits<double>::infinity()
8446  : std::numeric_limits<double>::quiet_NaN();
8447  default:
8448  return std::ldexp(mant + 1024, exp - 25);
8449  }
8450  }();
8451  return sax->number_float((half & 0x8000u) != 0
8452  ? static_cast<number_float_t>(-val)
8453  : static_cast<number_float_t>(val), "");
8454  }
8455 
8456  case 0xFA: // Single-Precision Float (four-byte IEEE 754)
8457  {
8458  float number{};
8459  return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
8460  }
8461 
8462  case 0xFB: // Double-Precision Float (eight-byte IEEE 754)
8463  {
8464  double number{};
8465  return get_number(input_format_t::cbor, number) && sax->number_float(static_cast<number_float_t>(number), "");
8466  }
8467 
8468  default: // anything else (0xFF is handled inside the other types)
8469  {
8470  auto last_token = get_token_string();
8471  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::cbor, "invalid byte: 0x" + last_token, "value")));
8472  }
8473  }
8474  }
8475 
8476  /*!
8477  @brief reads a CBOR string
8478 
8479  This function first reads starting bytes to determine the expected
8480  string length and then copies this number of bytes into a string.
8481  Additionally, CBOR's strings with indefinite lengths are supported.
8482 
8483  @param[out] result created string
8484 
8485  @return whether string creation completed
8486  */
8487  bool get_cbor_string(string_t& result)
8488  {
8489  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "string")))
8490  {
8491  return false;
8492  }
8493 
8494  switch (current)
8495  {
8496  // UTF-8 string (0x00..0x17 bytes follow)
8497  case 0x60:
8498  case 0x61:
8499  case 0x62:
8500  case 0x63:
8501  case 0x64:
8502  case 0x65:
8503  case 0x66:
8504  case 0x67:
8505  case 0x68:
8506  case 0x69:
8507  case 0x6A:
8508  case 0x6B:
8509  case 0x6C:
8510  case 0x6D:
8511  case 0x6E:
8512  case 0x6F:
8513  case 0x70:
8514  case 0x71:
8515  case 0x72:
8516  case 0x73:
8517  case 0x74:
8518  case 0x75:
8519  case 0x76:
8520  case 0x77:
8521  {
8522  return get_string(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
8523  }
8524 
8525  case 0x78: // UTF-8 string (one-byte uint8_t for n follows)
8526  {
8527  std::uint8_t len{};
8528  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8529  }
8530 
8531  case 0x79: // UTF-8 string (two-byte uint16_t for n follow)
8532  {
8533  std::uint16_t len{};
8534  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8535  }
8536 
8537  case 0x7A: // UTF-8 string (four-byte uint32_t for n follow)
8538  {
8539  std::uint32_t len{};
8540  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8541  }
8542 
8543  case 0x7B: // UTF-8 string (eight-byte uint64_t for n follow)
8544  {
8545  std::uint64_t len{};
8546  return get_number(input_format_t::cbor, len) && get_string(input_format_t::cbor, len, result);
8547  }
8548 
8549  case 0x7F: // UTF-8 string (indefinite length)
8550  {
8551  while (get() != 0xFF)
8552  {
8553  string_t chunk;
8554  if (!get_cbor_string(chunk))
8555  {
8556  return false;
8557  }
8558  result.append(chunk);
8559  }
8560  return true;
8561  }
8562 
8563  default:
8564  {
8565  auto last_token = get_token_string();
8566  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x60-0x7B) or indefinite string type (0x7F); last byte: 0x" + last_token, "string")));
8567  }
8568  }
8569  }
8570 
8571  /*!
8572  @brief reads a CBOR byte array
8573 
8574  This function first reads starting bytes to determine the expected
8575  byte array length and then copies this number of bytes into the byte array.
8576  Additionally, CBOR's byte arrays with indefinite lengths are supported.
8577 
8578  @param[out] result created byte array
8579 
8580  @return whether byte array creation completed
8581  */
8582  bool get_cbor_binary(binary_t& result)
8583  {
8584  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::cbor, "binary")))
8585  {
8586  return false;
8587  }
8588 
8589  switch (current)
8590  {
8591  // Binary data (0x00..0x17 bytes follow)
8592  case 0x40:
8593  case 0x41:
8594  case 0x42:
8595  case 0x43:
8596  case 0x44:
8597  case 0x45:
8598  case 0x46:
8599  case 0x47:
8600  case 0x48:
8601  case 0x49:
8602  case 0x4A:
8603  case 0x4B:
8604  case 0x4C:
8605  case 0x4D:
8606  case 0x4E:
8607  case 0x4F:
8608  case 0x50:
8609  case 0x51:
8610  case 0x52:
8611  case 0x53:
8612  case 0x54:
8613  case 0x55:
8614  case 0x56:
8615  case 0x57:
8616  {
8617  return get_binary(input_format_t::cbor, static_cast<unsigned int>(current) & 0x1Fu, result);
8618  }
8619 
8620  case 0x58: // Binary data (one-byte uint8_t for n follows)
8621  {
8622  std::uint8_t len{};
8623  return get_number(input_format_t::cbor, len) &&
8624  get_binary(input_format_t::cbor, len, result);
8625  }
8626 
8627  case 0x59: // Binary data (two-byte uint16_t for n follow)
8628  {
8629  std::uint16_t len{};
8630  return get_number(input_format_t::cbor, len) &&
8631  get_binary(input_format_t::cbor, len, result);
8632  }
8633 
8634  case 0x5A: // Binary data (four-byte uint32_t for n follow)
8635  {
8636  std::uint32_t len{};
8637  return get_number(input_format_t::cbor, len) &&
8638  get_binary(input_format_t::cbor, len, result);
8639  }
8640 
8641  case 0x5B: // Binary data (eight-byte uint64_t for n follow)
8642  {
8643  std::uint64_t len{};
8644  return get_number(input_format_t::cbor, len) &&
8645  get_binary(input_format_t::cbor, len, result);
8646  }
8647 
8648  case 0x5F: // Binary data (indefinite length)
8649  {
8650  while (get() != 0xFF)
8651  {
8652  binary_t chunk;
8653  if (!get_cbor_binary(chunk))
8654  {
8655  return false;
8656  }
8657  result.insert(result.end(), chunk.begin(), chunk.end());
8658  }
8659  return true;
8660  }
8661 
8662  default:
8663  {
8664  auto last_token = get_token_string();
8665  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::cbor, "expected length specification (0x40-0x5B) or indefinite binary array type (0x5F); last byte: 0x" + last_token, "binary")));
8666  }
8667  }
8668  }
8669 
8670  /*!
8671  @param[in] len the length of the array or std::size_t(-1) for an
8672  array of indefinite size
8673  @param[in] tag_handler how CBOR tags should be treated
8674  @return whether array creation completed
8675  */
8676  bool get_cbor_array(const std::size_t len,
8677  const cbor_tag_handler_t tag_handler)
8678  {
8679  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
8680  {
8681  return false;
8682  }
8683 
8684  if (len != std::size_t(-1))
8685  {
8686  for (std::size_t i = 0; i < len; ++i)
8687  {
8688  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
8689  {
8690  return false;
8691  }
8692  }
8693  }
8694  else
8695  {
8696  while (get() != 0xFF)
8697  {
8698  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(false, tag_handler)))
8699  {
8700  return false;
8701  }
8702  }
8703  }
8704 
8705  return sax->end_array();
8706  }
8707 
8708  /*!
8709  @param[in] len the length of the object or std::size_t(-1) for an
8710  object of indefinite size
8711  @param[in] tag_handler how CBOR tags should be treated
8712  @return whether object creation completed
8713  */
8714  bool get_cbor_object(const std::size_t len,
8715  const cbor_tag_handler_t tag_handler)
8716  {
8717  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
8718  {
8719  return false;
8720  }
8721 
8722  string_t key;
8723  if (len != std::size_t(-1))
8724  {
8725  for (std::size_t i = 0; i < len; ++i)
8726  {
8727  get();
8728  if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
8729  {
8730  return false;
8731  }
8732 
8733  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
8734  {
8735  return false;
8736  }
8737  key.clear();
8738  }
8739  }
8740  else
8741  {
8742  while (get() != 0xFF)
8743  {
8744  if (JSON_HEDLEY_UNLIKELY(!get_cbor_string(key) || !sax->key(key)))
8745  {
8746  return false;
8747  }
8748 
8749  if (JSON_HEDLEY_UNLIKELY(!parse_cbor_internal(true, tag_handler)))
8750  {
8751  return false;
8752  }
8753  key.clear();
8754  }
8755  }
8756 
8757  return sax->end_object();
8758  }
8759 
8760  /////////////
8761  // MsgPack //
8762  /////////////
8763 
8764  /*!
8765  @return whether a valid MessagePack value was passed to the SAX parser
8766  */
8768  {
8769  switch (get())
8770  {
8771  // EOF
8772  case std::char_traits<char_type>::eof():
8773  return unexpect_eof(input_format_t::msgpack, "value");
8774 
8775  // positive fixint
8776  case 0x00:
8777  case 0x01:
8778  case 0x02:
8779  case 0x03:
8780  case 0x04:
8781  case 0x05:
8782  case 0x06:
8783  case 0x07:
8784  case 0x08:
8785  case 0x09:
8786  case 0x0A:
8787  case 0x0B:
8788  case 0x0C:
8789  case 0x0D:
8790  case 0x0E:
8791  case 0x0F:
8792  case 0x10:
8793  case 0x11:
8794  case 0x12:
8795  case 0x13:
8796  case 0x14:
8797  case 0x15:
8798  case 0x16:
8799  case 0x17:
8800  case 0x18:
8801  case 0x19:
8802  case 0x1A:
8803  case 0x1B:
8804  case 0x1C:
8805  case 0x1D:
8806  case 0x1E:
8807  case 0x1F:
8808  case 0x20:
8809  case 0x21:
8810  case 0x22:
8811  case 0x23:
8812  case 0x24:
8813  case 0x25:
8814  case 0x26:
8815  case 0x27:
8816  case 0x28:
8817  case 0x29:
8818  case 0x2A:
8819  case 0x2B:
8820  case 0x2C:
8821  case 0x2D:
8822  case 0x2E:
8823  case 0x2F:
8824  case 0x30:
8825  case 0x31:
8826  case 0x32:
8827  case 0x33:
8828  case 0x34:
8829  case 0x35:
8830  case 0x36:
8831  case 0x37:
8832  case 0x38:
8833  case 0x39:
8834  case 0x3A:
8835  case 0x3B:
8836  case 0x3C:
8837  case 0x3D:
8838  case 0x3E:
8839  case 0x3F:
8840  case 0x40:
8841  case 0x41:
8842  case 0x42:
8843  case 0x43:
8844  case 0x44:
8845  case 0x45:
8846  case 0x46:
8847  case 0x47:
8848  case 0x48:
8849  case 0x49:
8850  case 0x4A:
8851  case 0x4B:
8852  case 0x4C:
8853  case 0x4D:
8854  case 0x4E:
8855  case 0x4F:
8856  case 0x50:
8857  case 0x51:
8858  case 0x52:
8859  case 0x53:
8860  case 0x54:
8861  case 0x55:
8862  case 0x56:
8863  case 0x57:
8864  case 0x58:
8865  case 0x59:
8866  case 0x5A:
8867  case 0x5B:
8868  case 0x5C:
8869  case 0x5D:
8870  case 0x5E:
8871  case 0x5F:
8872  case 0x60:
8873  case 0x61:
8874  case 0x62:
8875  case 0x63:
8876  case 0x64:
8877  case 0x65:
8878  case 0x66:
8879  case 0x67:
8880  case 0x68:
8881  case 0x69:
8882  case 0x6A:
8883  case 0x6B:
8884  case 0x6C:
8885  case 0x6D:
8886  case 0x6E:
8887  case 0x6F:
8888  case 0x70:
8889  case 0x71:
8890  case 0x72:
8891  case 0x73:
8892  case 0x74:
8893  case 0x75:
8894  case 0x76:
8895  case 0x77:
8896  case 0x78:
8897  case 0x79:
8898  case 0x7A:
8899  case 0x7B:
8900  case 0x7C:
8901  case 0x7D:
8902  case 0x7E:
8903  case 0x7F:
8904  return sax->number_unsigned(static_cast<number_unsigned_t>(current));
8905 
8906  // fixmap
8907  case 0x80:
8908  case 0x81:
8909  case 0x82:
8910  case 0x83:
8911  case 0x84:
8912  case 0x85:
8913  case 0x86:
8914  case 0x87:
8915  case 0x88:
8916  case 0x89:
8917  case 0x8A:
8918  case 0x8B:
8919  case 0x8C:
8920  case 0x8D:
8921  case 0x8E:
8922  case 0x8F:
8923  return get_msgpack_object(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
8924 
8925  // fixarray
8926  case 0x90:
8927  case 0x91:
8928  case 0x92:
8929  case 0x93:
8930  case 0x94:
8931  case 0x95:
8932  case 0x96:
8933  case 0x97:
8934  case 0x98:
8935  case 0x99:
8936  case 0x9A:
8937  case 0x9B:
8938  case 0x9C:
8939  case 0x9D:
8940  case 0x9E:
8941  case 0x9F:
8942  return get_msgpack_array(static_cast<std::size_t>(static_cast<unsigned int>(current) & 0x0Fu));
8943 
8944  // fixstr
8945  case 0xA0:
8946  case 0xA1:
8947  case 0xA2:
8948  case 0xA3:
8949  case 0xA4:
8950  case 0xA5:
8951  case 0xA6:
8952  case 0xA7:
8953  case 0xA8:
8954  case 0xA9:
8955  case 0xAA:
8956  case 0xAB:
8957  case 0xAC:
8958  case 0xAD:
8959  case 0xAE:
8960  case 0xAF:
8961  case 0xB0:
8962  case 0xB1:
8963  case 0xB2:
8964  case 0xB3:
8965  case 0xB4:
8966  case 0xB5:
8967  case 0xB6:
8968  case 0xB7:
8969  case 0xB8:
8970  case 0xB9:
8971  case 0xBA:
8972  case 0xBB:
8973  case 0xBC:
8974  case 0xBD:
8975  case 0xBE:
8976  case 0xBF:
8977  case 0xD9: // str 8
8978  case 0xDA: // str 16
8979  case 0xDB: // str 32
8980  {
8981  string_t s;
8982  return get_msgpack_string(s) && sax->string(s);
8983  }
8984 
8985  case 0xC0: // nil
8986  return sax->null();
8987 
8988  case 0xC2: // false
8989  return sax->boolean(false);
8990 
8991  case 0xC3: // true
8992  return sax->boolean(true);
8993 
8994  case 0xC4: // bin 8
8995  case 0xC5: // bin 16
8996  case 0xC6: // bin 32
8997  case 0xC7: // ext 8
8998  case 0xC8: // ext 16
8999  case 0xC9: // ext 32
9000  case 0xD4: // fixext 1
9001  case 0xD5: // fixext 2
9002  case 0xD6: // fixext 4
9003  case 0xD7: // fixext 8
9004  case 0xD8: // fixext 16
9005  {
9006  binary_t b;
9007  return get_msgpack_binary(b) && sax->binary(b);
9008  }
9009 
9010  case 0xCA: // float 32
9011  {
9012  float number{};
9013  return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
9014  }
9015 
9016  case 0xCB: // float 64
9017  {
9018  double number{};
9019  return get_number(input_format_t::msgpack, number) && sax->number_float(static_cast<number_float_t>(number), "");
9020  }
9021 
9022  case 0xCC: // uint 8
9023  {
9024  std::uint8_t number{};
9025  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9026  }
9027 
9028  case 0xCD: // uint 16
9029  {
9030  std::uint16_t number{};
9031  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9032  }
9033 
9034  case 0xCE: // uint 32
9035  {
9036  std::uint32_t number{};
9037  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9038  }
9039 
9040  case 0xCF: // uint 64
9041  {
9042  std::uint64_t number{};
9043  return get_number(input_format_t::msgpack, number) && sax->number_unsigned(number);
9044  }
9045 
9046  case 0xD0: // int 8
9047  {
9048  std::int8_t number{};
9049  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9050  }
9051 
9052  case 0xD1: // int 16
9053  {
9054  std::int16_t number{};
9055  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9056  }
9057 
9058  case 0xD2: // int 32
9059  {
9060  std::int32_t number{};
9061  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9062  }
9063 
9064  case 0xD3: // int 64
9065  {
9066  std::int64_t number{};
9067  return get_number(input_format_t::msgpack, number) && sax->number_integer(number);
9068  }
9069 
9070  case 0xDC: // array 16
9071  {
9072  std::uint16_t len{};
9073  return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
9074  }
9075 
9076  case 0xDD: // array 32
9077  {
9078  std::uint32_t len{};
9079  return get_number(input_format_t::msgpack, len) && get_msgpack_array(static_cast<std::size_t>(len));
9080  }
9081 
9082  case 0xDE: // map 16
9083  {
9084  std::uint16_t len{};
9085  return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
9086  }
9087 
9088  case 0xDF: // map 32
9089  {
9090  std::uint32_t len{};
9091  return get_number(input_format_t::msgpack, len) && get_msgpack_object(static_cast<std::size_t>(len));
9092  }
9093 
9094  // negative fixint
9095  case 0xE0:
9096  case 0xE1:
9097  case 0xE2:
9098  case 0xE3:
9099  case 0xE4:
9100  case 0xE5:
9101  case 0xE6:
9102  case 0xE7:
9103  case 0xE8:
9104  case 0xE9:
9105  case 0xEA:
9106  case 0xEB:
9107  case 0xEC:
9108  case 0xED:
9109  case 0xEE:
9110  case 0xEF:
9111  case 0xF0:
9112  case 0xF1:
9113  case 0xF2:
9114  case 0xF3:
9115  case 0xF4:
9116  case 0xF5:
9117  case 0xF6:
9118  case 0xF7:
9119  case 0xF8:
9120  case 0xF9:
9121  case 0xFA:
9122  case 0xFB:
9123  case 0xFC:
9124  case 0xFD:
9125  case 0xFE:
9126  case 0xFF:
9127  return sax->number_integer(static_cast<std::int8_t>(current));
9128 
9129  default: // anything else
9130  {
9131  auto last_token = get_token_string();
9132  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::msgpack, "invalid byte: 0x" + last_token, "value")));
9133  }
9134  }
9135  }
9136 
9137  /*!
9138  @brief reads a MessagePack string
9139 
9140  This function first reads starting bytes to determine the expected
9141  string length and then copies this number of bytes into a string.
9142 
9143  @param[out] result created string
9144 
9145  @return whether string creation completed
9146  */
9147  bool get_msgpack_string(string_t& result)
9148  {
9149  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::msgpack, "string")))
9150  {
9151  return false;
9152  }
9153 
9154  switch (current)
9155  {
9156  // fixstr
9157  case 0xA0:
9158  case 0xA1:
9159  case 0xA2:
9160  case 0xA3:
9161  case 0xA4:
9162  case 0xA5:
9163  case 0xA6:
9164  case 0xA7:
9165  case 0xA8:
9166  case 0xA9:
9167  case 0xAA:
9168  case 0xAB:
9169  case 0xAC:
9170  case 0xAD:
9171  case 0xAE:
9172  case 0xAF:
9173  case 0xB0:
9174  case 0xB1:
9175  case 0xB2:
9176  case 0xB3:
9177  case 0xB4:
9178  case 0xB5:
9179  case 0xB6:
9180  case 0xB7:
9181  case 0xB8:
9182  case 0xB9:
9183  case 0xBA:
9184  case 0xBB:
9185  case 0xBC:
9186  case 0xBD:
9187  case 0xBE:
9188  case 0xBF:
9189  {
9190  return get_string(input_format_t::msgpack, static_cast<unsigned int>(current) & 0x1Fu, result);
9191  }
9192 
9193  case 0xD9: // str 8
9194  {
9195  std::uint8_t len{};
9196  return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9197  }
9198 
9199  case 0xDA: // str 16
9200  {
9201  std::uint16_t len{};
9202  return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9203  }
9204 
9205  case 0xDB: // str 32
9206  {
9207  std::uint32_t len{};
9208  return get_number(input_format_t::msgpack, len) && get_string(input_format_t::msgpack, len, result);
9209  }
9210 
9211  default:
9212  {
9213  auto last_token = get_token_string();
9214  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::msgpack, "expected length specification (0xA0-0xBF, 0xD9-0xDB); last byte: 0x" + last_token, "string")));
9215  }
9216  }
9217  }
9218 
9219  /*!
9220  @brief reads a MessagePack byte array
9221 
9222  This function first reads starting bytes to determine the expected
9223  byte array length and then copies this number of bytes into a byte array.
9224 
9225  @param[out] result created byte array
9226 
9227  @return whether byte array creation completed
9228  */
9229  bool get_msgpack_binary(binary_t& result)
9230  {
9231  // helper function to set the subtype
9232  auto assign_and_return_true = [&result](std::int8_t subtype)
9233  {
9234  result.set_subtype(static_cast<std::uint8_t>(subtype));
9235  return true;
9236  };
9237 
9238  switch (current)
9239  {
9240  case 0xC4: // bin 8
9241  {
9242  std::uint8_t len{};
9243  return get_number(input_format_t::msgpack, len) &&
9244  get_binary(input_format_t::msgpack, len, result);
9245  }
9246 
9247  case 0xC5: // bin 16
9248  {
9249  std::uint16_t len{};
9250  return get_number(input_format_t::msgpack, len) &&
9251  get_binary(input_format_t::msgpack, len, result);
9252  }
9253 
9254  case 0xC6: // bin 32
9255  {
9256  std::uint32_t len{};
9257  return get_number(input_format_t::msgpack, len) &&
9258  get_binary(input_format_t::msgpack, len, result);
9259  }
9260 
9261  case 0xC7: // ext 8
9262  {
9263  std::uint8_t len{};
9264  std::int8_t subtype{};
9265  return get_number(input_format_t::msgpack, len) &&
9266  get_number(input_format_t::msgpack, subtype) &&
9267  get_binary(input_format_t::msgpack, len, result) &&
9268  assign_and_return_true(subtype);
9269  }
9270 
9271  case 0xC8: // ext 16
9272  {
9273  std::uint16_t len{};
9274  std::int8_t subtype{};
9275  return get_number(input_format_t::msgpack, len) &&
9276  get_number(input_format_t::msgpack, subtype) &&
9277  get_binary(input_format_t::msgpack, len, result) &&
9278  assign_and_return_true(subtype);
9279  }
9280 
9281  case 0xC9: // ext 32
9282  {
9283  std::uint32_t len{};
9284  std::int8_t subtype{};
9285  return get_number(input_format_t::msgpack, len) &&
9286  get_number(input_format_t::msgpack, subtype) &&
9287  get_binary(input_format_t::msgpack, len, result) &&
9288  assign_and_return_true(subtype);
9289  }
9290 
9291  case 0xD4: // fixext 1
9292  {
9293  std::int8_t subtype{};
9294  return get_number(input_format_t::msgpack, subtype) &&
9295  get_binary(input_format_t::msgpack, 1, result) &&
9296  assign_and_return_true(subtype);
9297  }
9298 
9299  case 0xD5: // fixext 2
9300  {
9301  std::int8_t subtype{};
9302  return get_number(input_format_t::msgpack, subtype) &&
9303  get_binary(input_format_t::msgpack, 2, result) &&
9304  assign_and_return_true(subtype);
9305  }
9306 
9307  case 0xD6: // fixext 4
9308  {
9309  std::int8_t subtype{};
9310  return get_number(input_format_t::msgpack, subtype) &&
9311  get_binary(input_format_t::msgpack, 4, result) &&
9312  assign_and_return_true(subtype);
9313  }
9314 
9315  case 0xD7: // fixext 8
9316  {
9317  std::int8_t subtype{};
9318  return get_number(input_format_t::msgpack, subtype) &&
9319  get_binary(input_format_t::msgpack, 8, result) &&
9320  assign_and_return_true(subtype);
9321  }
9322 
9323  case 0xD8: // fixext 16
9324  {
9325  std::int8_t subtype{};
9326  return get_number(input_format_t::msgpack, subtype) &&
9327  get_binary(input_format_t::msgpack, 16, result) &&
9328  assign_and_return_true(subtype);
9329  }
9330 
9331  default: // LCOV_EXCL_LINE
9332  return false; // LCOV_EXCL_LINE
9333  }
9334  }
9335 
9336  /*!
9337  @param[in] len the length of the array
9338  @return whether array creation completed
9339  */
9340  bool get_msgpack_array(const std::size_t len)
9341  {
9342  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(len)))
9343  {
9344  return false;
9345  }
9346 
9347  for (std::size_t i = 0; i < len; ++i)
9348  {
9349  if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9350  {
9351  return false;
9352  }
9353  }
9354 
9355  return sax->end_array();
9356  }
9357 
9358  /*!
9359  @param[in] len the length of the object
9360  @return whether object creation completed
9361  */
9362  bool get_msgpack_object(const std::size_t len)
9363  {
9364  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(len)))
9365  {
9366  return false;
9367  }
9368 
9369  string_t key;
9370  for (std::size_t i = 0; i < len; ++i)
9371  {
9372  get();
9373  if (JSON_HEDLEY_UNLIKELY(!get_msgpack_string(key) || !sax->key(key)))
9374  {
9375  return false;
9376  }
9377 
9378  if (JSON_HEDLEY_UNLIKELY(!parse_msgpack_internal()))
9379  {
9380  return false;
9381  }
9382  key.clear();
9383  }
9384 
9385  return sax->end_object();
9386  }
9387 
9388  ////////////
9389  // UBJSON //
9390  ////////////
9391 
9392  /*!
9393  @param[in] get_char whether a new character should be retrieved from the
9394  input (true, default) or whether the last read
9395  character should be considered instead
9396 
9397  @return whether a valid UBJSON value was passed to the SAX parser
9398  */
9399  bool parse_ubjson_internal(const bool get_char = true)
9400  {
9401  return get_ubjson_value(get_char ? get_ignore_noop() : current);
9402  }
9403 
9404  /*!
9405  @brief reads a UBJSON string
9406 
9407  This function is either called after reading the 'S' byte explicitly
9408  indicating a string, or in case of an object key where the 'S' byte can be
9409  left out.
9410 
9411  @param[out] result created string
9412  @param[in] get_char whether a new character should be retrieved from the
9413  input (true, default) or whether the last read
9414  character should be considered instead
9415 
9416  @return whether string creation completed
9417  */
9418  bool get_ubjson_string(string_t& result, const bool get_char = true)
9419  {
9420  if (get_char)
9421  {
9422  get(); // TODO(niels): may we ignore N here?
9423  }
9424 
9425  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
9426  {
9427  return false;
9428  }
9429 
9430  switch (current)
9431  {
9432  case 'U':
9433  {
9434  std::uint8_t len{};
9435  return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9436  }
9437 
9438  case 'i':
9439  {
9440  std::int8_t len{};
9441  return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9442  }
9443 
9444  case 'I':
9445  {
9446  std::int16_t len{};
9447  return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9448  }
9449 
9450  case 'l':
9451  {
9452  std::int32_t len{};
9453  return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9454  }
9455 
9456  case 'L':
9457  {
9458  std::int64_t len{};
9459  return get_number(input_format_t::ubjson, len) && get_string(input_format_t::ubjson, len, result);
9460  }
9461 
9462  default:
9463  auto last_token = get_token_string();
9464  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L); last byte: 0x" + last_token, "string")));
9465  }
9466  }
9467 
9468  /*!
9469  @param[out] result determined size
9470  @return whether size determination completed
9471  */
9472  bool get_ubjson_size_value(std::size_t& result)
9473  {
9474  switch (get_ignore_noop())
9475  {
9476  case 'U':
9477  {
9478  std::uint8_t number{};
9479  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9480  {
9481  return false;
9482  }
9483  result = static_cast<std::size_t>(number);
9484  return true;
9485  }
9486 
9487  case 'i':
9488  {
9489  std::int8_t number{};
9490  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9491  {
9492  return false;
9493  }
9494  result = static_cast<std::size_t>(number);
9495  return true;
9496  }
9497 
9498  case 'I':
9499  {
9500  std::int16_t number{};
9501  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9502  {
9503  return false;
9504  }
9505  result = static_cast<std::size_t>(number);
9506  return true;
9507  }
9508 
9509  case 'l':
9510  {
9511  std::int32_t number{};
9512  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9513  {
9514  return false;
9515  }
9516  result = static_cast<std::size_t>(number);
9517  return true;
9518  }
9519 
9520  case 'L':
9521  {
9522  std::int64_t number{};
9523  if (JSON_HEDLEY_UNLIKELY(!get_number(input_format_t::ubjson, number)))
9524  {
9525  return false;
9526  }
9527  result = static_cast<std::size_t>(number);
9528  return true;
9529  }
9530 
9531  default:
9532  {
9533  auto last_token = get_token_string();
9534  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "expected length type specification (U, i, I, l, L) after '#'; last byte: 0x" + last_token, "size")));
9535  }
9536  }
9537  }
9538 
9539  /*!
9540  @brief determine the type and size for a container
9541 
9542  In the optimized UBJSON format, a type and a size can be provided to allow
9543  for a more compact representation.
9544 
9545  @param[out] result pair of the size and the type
9546 
9547  @return whether pair creation completed
9548  */
9549  bool get_ubjson_size_type(std::pair<std::size_t, char_int_type>& result)
9550  {
9551  result.first = string_t::npos; // size
9552  result.second = 0; // type
9553 
9554  get_ignore_noop();
9555 
9556  if (current == '$')
9557  {
9558  result.second = get(); // must not ignore 'N', because 'N' maybe the type
9559  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "type")))
9560  {
9561  return false;
9562  }
9563 
9564  get_ignore_noop();
9565  if (JSON_HEDLEY_UNLIKELY(current != '#'))
9566  {
9567  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "value")))
9568  {
9569  return false;
9570  }
9571  auto last_token = get_token_string();
9572  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "expected '#' after type information; last byte: 0x" + last_token, "size")));
9573  }
9574 
9575  return get_ubjson_size_value(result.first);
9576  }
9577 
9578  if (current == '#')
9579  {
9580  return get_ubjson_size_value(result.first);
9581  }
9582 
9583  return true;
9584  }
9585 
9586  /*!
9587  @param prefix the previously read or set type prefix
9588  @return whether value creation completed
9589  */
9590  bool get_ubjson_value(const char_int_type prefix)
9591  {
9592  switch (prefix)
9593  {
9594  case std::char_traits<char_type>::eof(): // EOF
9595  return unexpect_eof(input_format_t::ubjson, "value");
9596 
9597  case 'T': // true
9598  return sax->boolean(true);
9599  case 'F': // false
9600  return sax->boolean(false);
9601 
9602  case 'Z': // null
9603  return sax->null();
9604 
9605  case 'U':
9606  {
9607  std::uint8_t number{};
9608  return get_number(input_format_t::ubjson, number) && sax->number_unsigned(number);
9609  }
9610 
9611  case 'i':
9612  {
9613  std::int8_t number{};
9614  return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9615  }
9616 
9617  case 'I':
9618  {
9619  std::int16_t number{};
9620  return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9621  }
9622 
9623  case 'l':
9624  {
9625  std::int32_t number{};
9626  return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9627  }
9628 
9629  case 'L':
9630  {
9631  std::int64_t number{};
9632  return get_number(input_format_t::ubjson, number) && sax->number_integer(number);
9633  }
9634 
9635  case 'd':
9636  {
9637  float number{};
9638  return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
9639  }
9640 
9641  case 'D':
9642  {
9643  double number{};
9644  return get_number(input_format_t::ubjson, number) && sax->number_float(static_cast<number_float_t>(number), "");
9645  }
9646 
9647  case 'H':
9648  {
9649  return get_ubjson_high_precision_number();
9650  }
9651 
9652  case 'C': // char
9653  {
9654  get();
9655  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "char")))
9656  {
9657  return false;
9658  }
9659  if (JSON_HEDLEY_UNLIKELY(current > 127))
9660  {
9661  auto last_token = get_token_string();
9662  return sax->parse_error(chars_read, last_token, parse_error::create(113, chars_read, exception_message(input_format_t::ubjson, "byte after 'C' must be in range 0x00..0x7F; last byte: 0x" + last_token, "char")));
9663  }
9664  string_t s(1, static_cast<typename string_t::value_type>(current));
9665  return sax->string(s);
9666  }
9667 
9668  case 'S': // string
9669  {
9670  string_t s;
9671  return get_ubjson_string(s) && sax->string(s);
9672  }
9673 
9674  case '[': // array
9675  return get_ubjson_array();
9676 
9677  case '{': // object
9678  return get_ubjson_object();
9679 
9680  default: // anything else
9681  {
9682  auto last_token = get_token_string();
9683  return sax->parse_error(chars_read, last_token, parse_error::create(112, chars_read, exception_message(input_format_t::ubjson, "invalid byte: 0x" + last_token, "value")));
9684  }
9685  }
9686  }
9687 
9688  /*!
9689  @return whether array creation completed
9690  */
9692  {
9693  std::pair<std::size_t, char_int_type> size_and_type;
9694  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
9695  {
9696  return false;
9697  }
9698 
9699  if (size_and_type.first != string_t::npos)
9700  {
9701  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(size_and_type.first)))
9702  {
9703  return false;
9704  }
9705 
9706  if (size_and_type.second != 0)
9707  {
9708  if (size_and_type.second != 'N')
9709  {
9710  for (std::size_t i = 0; i < size_and_type.first; ++i)
9711  {
9712  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
9713  {
9714  return false;
9715  }
9716  }
9717  }
9718  }
9719  else
9720  {
9721  for (std::size_t i = 0; i < size_and_type.first; ++i)
9722  {
9723  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
9724  {
9725  return false;
9726  }
9727  }
9728  }
9729  }
9730  else
9731  {
9732  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
9733  {
9734  return false;
9735  }
9736 
9737  while (current != ']')
9738  {
9739  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal(false)))
9740  {
9741  return false;
9742  }
9743  get_ignore_noop();
9744  }
9745  }
9746 
9747  return sax->end_array();
9748  }
9749 
9750  /*!
9751  @return whether object creation completed
9752  */
9754  {
9755  std::pair<std::size_t, char_int_type> size_and_type;
9756  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_size_type(size_and_type)))
9757  {
9758  return false;
9759  }
9760 
9761  string_t key;
9762  if (size_and_type.first != string_t::npos)
9763  {
9764  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(size_and_type.first)))
9765  {
9766  return false;
9767  }
9768 
9769  if (size_and_type.second != 0)
9770  {
9771  for (std::size_t i = 0; i < size_and_type.first; ++i)
9772  {
9773  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
9774  {
9775  return false;
9776  }
9777  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_value(size_and_type.second)))
9778  {
9779  return false;
9780  }
9781  key.clear();
9782  }
9783  }
9784  else
9785  {
9786  for (std::size_t i = 0; i < size_and_type.first; ++i)
9787  {
9788  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key) || !sax->key(key)))
9789  {
9790  return false;
9791  }
9792  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
9793  {
9794  return false;
9795  }
9796  key.clear();
9797  }
9798  }
9799  }
9800  else
9801  {
9802  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
9803  {
9804  return false;
9805  }
9806 
9807  while (current != '}')
9808  {
9809  if (JSON_HEDLEY_UNLIKELY(!get_ubjson_string(key, false) || !sax->key(key)))
9810  {
9811  return false;
9812  }
9813  if (JSON_HEDLEY_UNLIKELY(!parse_ubjson_internal()))
9814  {
9815  return false;
9816  }
9817  get_ignore_noop();
9818  key.clear();
9819  }
9820  }
9821 
9822  return sax->end_object();
9823  }
9824 
9825  // Note, no reader for UBJSON binary types is implemented because they do
9826  // not exist
9827 
9828  bool get_ubjson_high_precision_number()
9829  {
9830  // get size of following number string
9831  std::size_t size{};
9832  auto res = get_ubjson_size_value(size);
9833  if (JSON_HEDLEY_UNLIKELY(!res))
9834  {
9835  return res;
9836  }
9837 
9838  // get number string
9839  std::vector<char> number_vector;
9840  for (std::size_t i = 0; i < size; ++i)
9841  {
9842  get();
9843  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(input_format_t::ubjson, "number")))
9844  {
9845  return false;
9846  }
9847  number_vector.push_back(static_cast<char>(current));
9848  }
9849 
9850  // parse number string
9851  auto number_ia = detail::input_adapter(std::forward<decltype(number_vector)>(number_vector));
9852  auto number_lexer = detail::lexer<BasicJsonType, decltype(number_ia)>(std::move(number_ia), false);
9853  const auto result_number = number_lexer.scan();
9854  const auto number_string = number_lexer.get_token_string();
9855  const auto result_remainder = number_lexer.scan();
9856 
9857  using token_type = typename detail::lexer_base<BasicJsonType>::token_type;
9858 
9859  if (JSON_HEDLEY_UNLIKELY(result_remainder != token_type::end_of_input))
9860  {
9861  return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
9862  }
9863 
9864  switch (result_number)
9865  {
9866  case token_type::value_integer:
9867  return sax->number_integer(number_lexer.get_number_integer());
9868  case token_type::value_unsigned:
9869  return sax->number_unsigned(number_lexer.get_number_unsigned());
9870  case token_type::value_float:
9871  return sax->number_float(number_lexer.get_number_float(), std::move(number_string));
9872  default:
9873  return sax->parse_error(chars_read, number_string, parse_error::create(115, chars_read, exception_message(input_format_t::ubjson, "invalid number text: " + number_lexer.get_token_string(), "high-precision number")));
9874  }
9875  }
9876 
9877  ///////////////////////
9878  // Utility functions //
9879  ///////////////////////
9880 
9881  /*!
9882  @brief get next character from the input
9883 
9884  This function provides the interface to the used input adapter. It does
9885  not throw in case the input reached EOF, but returns a -'ve valued
9886  `std::char_traits<char_type>::eof()` in that case.
9887 
9888  @return character read from the input
9889  */
9890  char_int_type get()
9891  {
9892  ++chars_read;
9893  return current = ia.get_character();
9894  }
9895 
9896  /*!
9897  @return character read from the input after ignoring all 'N' entries
9898  */
9899  char_int_type get_ignore_noop()
9900  {
9901  do
9902  {
9903  get();
9904  }
9905  while (current == 'N');
9906 
9907  return current;
9908  }
9909 
9910  /*
9911  @brief read a number from the input
9912 
9913  @tparam NumberType the type of the number
9914  @param[in] format the current format (for diagnostics)
9915  @param[out] result number of type @a NumberType
9916 
9917  @return whether conversion completed
9918 
9919  @note This function needs to respect the system's endianess, because
9920  bytes in CBOR, MessagePack, and UBJSON are stored in network order
9921  (big endian) and therefore need reordering on little endian systems.
9922  */
9923  template<typename NumberType, bool InputIsLittleEndian = false>
9924  bool get_number(const input_format_t format, NumberType& result)
9925  {
9926  // step 1: read input into array with system's byte order
9927  std::array<std::uint8_t, sizeof(NumberType)> vec;
9928  for (std::size_t i = 0; i < sizeof(NumberType); ++i)
9929  {
9930  get();
9931  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "number")))
9932  {
9933  return false;
9934  }
9935 
9936  // reverse byte order prior to conversion if necessary
9937  if (is_little_endian != InputIsLittleEndian)
9938  {
9939  vec[sizeof(NumberType) - i - 1] = static_cast<std::uint8_t>(current);
9940  }
9941  else
9942  {
9943  vec[i] = static_cast<std::uint8_t>(current); // LCOV_EXCL_LINE
9944  }
9945  }
9946 
9947  // step 2: convert array into number of type T and return
9948  std::memcpy(&result, vec.data(), sizeof(NumberType));
9949  return true;
9950  }
9951 
9952  /*!
9953  @brief create a string by reading characters from the input
9954 
9955  @tparam NumberType the type of the number
9956  @param[in] format the current format (for diagnostics)
9957  @param[in] len number of characters to read
9958  @param[out] result string created by reading @a len bytes
9959 
9960  @return whether string creation completed
9961 
9962  @note We can not reserve @a len bytes for the result, because @a len
9963  may be too large. Usually, @ref unexpect_eof() detects the end of
9964  the input before we run out of string memory.
9965  */
9966  template<typename NumberType>
9967  bool get_string(const input_format_t format,
9968  const NumberType len,
9969  string_t& result)
9970  {
9971  bool success = true;
9972  for (NumberType i = 0; i < len; i++)
9973  {
9974  get();
9975  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "string")))
9976  {
9977  success = false;
9978  break;
9979  }
9980  result.push_back(static_cast<typename string_t::value_type>(current));
9981  };
9982  return success;
9983  }
9984 
9985  /*!
9986  @brief create a byte array by reading bytes from the input
9987 
9988  @tparam NumberType the type of the number
9989  @param[in] format the current format (for diagnostics)
9990  @param[in] len number of bytes to read
9991  @param[out] result byte array created by reading @a len bytes
9992 
9993  @return whether byte array creation completed
9994 
9995  @note We can not reserve @a len bytes for the result, because @a len
9996  may be too large. Usually, @ref unexpect_eof() detects the end of
9997  the input before we run out of memory.
9998  */
9999  template<typename NumberType>
10000  bool get_binary(const input_format_t format,
10001  const NumberType len,
10002  binary_t& result)
10003  {
10004  bool success = true;
10005  for (NumberType i = 0; i < len; i++)
10006  {
10007  get();
10008  if (JSON_HEDLEY_UNLIKELY(!unexpect_eof(format, "binary")))
10009  {
10010  success = false;
10011  break;
10012  }
10013  result.push_back(static_cast<std::uint8_t>(current));
10014  }
10015  return success;
10016  }
10017 
10018  /*!
10019  @param[in] format the current format (for diagnostics)
10020  @param[in] context further context information (for diagnostics)
10021  @return whether the last read character is not EOF
10022  */
10023  JSON_HEDLEY_NON_NULL(3)
10024  bool unexpect_eof(const input_format_t format, const char* context) const
10025  {
10026  if (JSON_HEDLEY_UNLIKELY(current == std::char_traits<char_type>::eof()))
10027  {
10028  return sax->parse_error(chars_read, "<end of file>",
10029  parse_error::create(110, chars_read, exception_message(format, "unexpected end of input", context)));
10030  }
10031  return true;
10032  }
10033 
10034  /*!
10035  @return a string representation of the last read byte
10036  */
10037  std::string get_token_string() const
10038  {
10039  std::array<char, 3> cr{{}};
10040  (std::snprintf)(cr.data(), cr.size(), "%.2hhX", static_cast<unsigned char>(current));
10041  return std::string{cr.data()};
10042  }
10043 
10044  /*!
10045  @param[in] format the current format
10046  @param[in] detail a detailed error message
10047  @param[in] context further context information
10048  @return a message string to use in the parse_error exceptions
10049  */
10050  std::string exception_message(const input_format_t format,
10051  const std::string& detail,
10052  const std::string& context) const
10053  {
10054  std::string error_msg = "syntax error while parsing ";
10055 
10056  switch (format)
10057  {
10058  case input_format_t::cbor:
10059  error_msg += "CBOR";
10060  break;
10061 
10062  case input_format_t::msgpack:
10063  error_msg += "MessagePack";
10064  break;
10065 
10066  case input_format_t::ubjson:
10067  error_msg += "UBJSON";
10068  break;
10069 
10070  case input_format_t::bson:
10071  error_msg += "BSON";
10072  break;
10073 
10074  default: // LCOV_EXCL_LINE
10075  JSON_ASSERT(false); // LCOV_EXCL_LINE
10076  }
10077 
10078  return error_msg + " " + context + ": " + detail;
10079  }
10080 
10081  private:
10082  /// input adapter
10083  InputAdapterType ia;
10084 
10085  /// the current character
10086  char_int_type current = std::char_traits<char_type>::eof();
10087 
10088  /// the number of characters read
10089  std::size_t chars_read = 0;
10090 
10091  /// whether we can assume little endianess
10093 
10094  /// the SAX parser
10095  json_sax_t* sax = nullptr;
10096 };
10097 } // namespace detail
10098 } // namespace nlohmann
10099 
10100 // #include <nlohmann/detail/input/input_adapters.hpp>
10101 
10102 // #include <nlohmann/detail/input/lexer.hpp>
10103 
10104 // #include <nlohmann/detail/input/parser.hpp>
10105 
10106 
10107 #include <cmath> // isfinite
10108 #include <cstdint> // uint8_t
10109 #include <functional> // function
10110 #include <string> // string
10111 #include <utility> // move
10112 #include <vector> // vector
10113 
10114 // #include <nlohmann/detail/exceptions.hpp>
10115 
10116 // #include <nlohmann/detail/input/input_adapters.hpp>
10117 
10118 // #include <nlohmann/detail/input/json_sax.hpp>
10119 
10120 // #include <nlohmann/detail/input/lexer.hpp>
10121 
10122 // #include <nlohmann/detail/macro_scope.hpp>
10123 
10124 // #include <nlohmann/detail/meta/is_sax.hpp>
10125 
10126 // #include <nlohmann/detail/value_t.hpp>
10127 
10128 
10129 namespace nlohmann
10130 {
10131 namespace detail
10132 {
10133 ////////////
10134 // parser //
10135 ////////////
10136 
10137 enum class parse_event_t : uint8_t
10138 {
10139  /// the parser read `{` and started to process a JSON object
10140  object_start,
10141  /// the parser read `}` and finished processing a JSON object
10142  object_end,
10143  /// the parser read `[` and started to process a JSON array
10144  array_start,
10145  /// the parser read `]` and finished processing a JSON array
10146  array_end,
10147  /// the parser read a key of a value in an object
10148  key,
10149  /// the parser finished reading a JSON value
10150  value
10151 };
10152 
10153 template<typename BasicJsonType>
10154 using parser_callback_t =
10155  std::function<bool(int depth, parse_event_t event, BasicJsonType& parsed)>;
10156 
10157 /*!
10158 @brief syntax analysis
10159 
10160 This class implements a recursive descent parser.
10161 */
10162 template<typename BasicJsonType, typename InputAdapterType>
10163 class parser
10164 {
10165  using number_integer_t = typename BasicJsonType::number_integer_t;
10166  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
10167  using number_float_t = typename BasicJsonType::number_float_t;
10168  using string_t = typename BasicJsonType::string_t;
10170  using token_type = typename lexer_t::token_type;
10171 
10172  public:
10173  /// a parser reading from an input adapter
10174  explicit parser(InputAdapterType&& adapter,
10175  const parser_callback_t<BasicJsonType> cb = nullptr,
10176  const bool allow_exceptions_ = true,
10177  const bool skip_comments = false)
10178  : callback(cb)
10179  , m_lexer(std::move(adapter), skip_comments)
10180  , allow_exceptions(allow_exceptions_)
10181  {
10182  // read first token
10183  get_token();
10184  }
10185 
10186  /*!
10187  @brief public parser interface
10188 
10189  @param[in] strict whether to expect the last token to be EOF
10190  @param[in,out] result parsed JSON value
10191 
10192  @throw parse_error.101 in case of an unexpected token
10193  @throw parse_error.102 if to_unicode fails or surrogate error
10194  @throw parse_error.103 if to_unicode fails
10195  */
10196  void parse(const bool strict, BasicJsonType& result)
10197  {
10198  if (callback)
10199  {
10201  sax_parse_internal(&sdp);
10202  result.assert_invariant();
10203 
10204  // in strict mode, input must be completely read
10205  if (strict && (get_token() != token_type::end_of_input))
10206  {
10207  sdp.parse_error(m_lexer.get_position(),
10210  exception_message(token_type::end_of_input, "value")));
10211  }
10212 
10213  // in case of an error, return discarded value
10214  if (sdp.is_errored())
10215  {
10216  result = value_t::discarded;
10217  return;
10218  }
10219 
10220  // set top-level value to null if it was discarded by the callback
10221  // function
10222  if (result.is_discarded())
10223  {
10224  result = nullptr;
10225  }
10226  }
10227  else
10228  {
10230  sax_parse_internal(&sdp);
10231  result.assert_invariant();
10232 
10233  // in strict mode, input must be completely read
10234  if (strict && (get_token() != token_type::end_of_input))
10235  {
10236  sdp.parse_error(m_lexer.get_position(),
10239  exception_message(token_type::end_of_input, "value")));
10240  }
10241 
10242  // in case of an error, return discarded value
10243  if (sdp.is_errored())
10244  {
10245  result = value_t::discarded;
10246  return;
10247  }
10248  }
10249  }
10250 
10251  /*!
10252  @brief public accept interface
10253 
10254  @param[in] strict whether to expect the last token to be EOF
10255  @return whether the input is a proper JSON text
10256  */
10257  bool accept(const bool strict = true)
10258  {
10259  json_sax_acceptor<BasicJsonType> sax_acceptor;
10260  return sax_parse(&sax_acceptor, strict);
10261  }
10262 
10263  template<typename SAX>
10264  JSON_HEDLEY_NON_NULL(2)
10265  bool sax_parse(SAX* sax, const bool strict = true)
10266  {
10268  const bool result = sax_parse_internal(sax);
10269 
10270  // strict mode: next byte must be EOF
10271  if (result && strict && (get_token() != token_type::end_of_input))
10272  {
10273  return sax->parse_error(m_lexer.get_position(),
10276  exception_message(token_type::end_of_input, "value")));
10277  }
10278 
10279  return result;
10280  }
10281 
10282  private:
10283  template<typename SAX>
10284  JSON_HEDLEY_NON_NULL(2)
10285  bool sax_parse_internal(SAX* sax)
10286  {
10287  // stack to remember the hierarchy of structured values we are parsing
10288  // true = array; false = object
10289  std::vector<bool> states;
10290  // value to avoid a goto (see comment where set to true)
10291  bool skip_to_state_evaluation = false;
10292 
10293  while (true)
10294  {
10295  if (!skip_to_state_evaluation)
10296  {
10297  // invariant: get_token() was called before each iteration
10298  switch (last_token)
10299  {
10300  case token_type::begin_object:
10301  {
10302  if (JSON_HEDLEY_UNLIKELY(!sax->start_object(std::size_t(-1))))
10303  {
10304  return false;
10305  }
10306 
10307  // closing } -> we are done
10308  if (get_token() == token_type::end_object)
10309  {
10310  if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
10311  {
10312  return false;
10313  }
10314  break;
10315  }
10316 
10317  // parse key
10318  if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
10319  {
10320  return sax->parse_error(m_lexer.get_position(),
10323  exception_message(token_type::value_string, "object key")));
10324  }
10325  if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
10326  {
10327  return false;
10328  }
10329 
10330  // parse separator (:)
10331  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
10332  {
10333  return sax->parse_error(m_lexer.get_position(),
10336  exception_message(token_type::name_separator, "object separator")));
10337  }
10338 
10339  // remember we are now inside an object
10340  states.push_back(false);
10341 
10342  // parse values
10343  get_token();
10344  continue;
10345  }
10346 
10347  case token_type::begin_array:
10348  {
10349  if (JSON_HEDLEY_UNLIKELY(!sax->start_array(std::size_t(-1))))
10350  {
10351  return false;
10352  }
10353 
10354  // closing ] -> we are done
10355  if (get_token() == token_type::end_array)
10356  {
10357  if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
10358  {
10359  return false;
10360  }
10361  break;
10362  }
10363 
10364  // remember we are now inside an array
10365  states.push_back(true);
10366 
10367  // parse values (no need to call get_token)
10368  continue;
10369  }
10370 
10371  case token_type::value_float:
10372  {
10373  const auto res = m_lexer.get_number_float();
10374 
10375  if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
10376  {
10377  return sax->parse_error(m_lexer.get_position(),
10379  out_of_range::create(406, "number overflow parsing '" + m_lexer.get_token_string() + "'"));
10380  }
10381 
10382  if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
10383  {
10384  return false;
10385  }
10386 
10387  break;
10388  }
10389 
10390  case token_type::literal_false:
10391  {
10392  if (JSON_HEDLEY_UNLIKELY(!sax->boolean(false)))
10393  {
10394  return false;
10395  }
10396  break;
10397  }
10398 
10399  case token_type::literal_null:
10400  {
10401  if (JSON_HEDLEY_UNLIKELY(!sax->null()))
10402  {
10403  return false;
10404  }
10405  break;
10406  }
10407 
10408  case token_type::literal_true:
10409  {
10410  if (JSON_HEDLEY_UNLIKELY(!sax->boolean(true)))
10411  {
10412  return false;
10413  }
10414  break;
10415  }
10416 
10417  case token_type::value_integer:
10418  {
10419  if (JSON_HEDLEY_UNLIKELY(!sax->number_integer(m_lexer.get_number_integer())))
10420  {
10421  return false;
10422  }
10423  break;
10424  }
10425 
10426  case token_type::value_string:
10427  {
10428  if (JSON_HEDLEY_UNLIKELY(!sax->string(m_lexer.get_string())))
10429  {
10430  return false;
10431  }
10432  break;
10433  }
10434 
10435  case token_type::value_unsigned:
10436  {
10437  if (JSON_HEDLEY_UNLIKELY(!sax->number_unsigned(m_lexer.get_number_unsigned())))
10438  {
10439  return false;
10440  }
10441  break;
10442  }
10443 
10444  case token_type::parse_error:
10445  {
10446  // using "uninitialized" to avoid "expected" message
10447  return sax->parse_error(m_lexer.get_position(),
10450  exception_message(token_type::uninitialized, "value")));
10451  }
10452 
10453  default: // the last token was unexpected
10454  {
10455  return sax->parse_error(m_lexer.get_position(),
10458  exception_message(token_type::literal_or_value, "value")));
10459  }
10460  }
10461  }
10462  else
10463  {
10464  skip_to_state_evaluation = false;
10465  }
10466 
10467  // we reached this line after we successfully parsed a value
10468  if (states.empty())
10469  {
10470  // empty stack: we reached the end of the hierarchy: done
10471  return true;
10472  }
10473 
10474  if (states.back()) // array
10475  {
10476  // comma -> next value
10477  if (get_token() == token_type::value_separator)
10478  {
10479  // parse a new value
10480  get_token();
10481  continue;
10482  }
10483 
10484  // closing ]
10485  if (JSON_HEDLEY_LIKELY(last_token == token_type::end_array))
10486  {
10487  if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
10488  {
10489  return false;
10490  }
10491 
10492  // We are done with this array. Before we can parse a
10493  // new value, we need to evaluate the new state first.
10494  // By setting skip_to_state_evaluation to false, we
10495  // are effectively jumping to the beginning of this if.
10496  JSON_ASSERT(!states.empty());
10497  states.pop_back();
10498  skip_to_state_evaluation = true;
10499  continue;
10500  }
10501 
10502  return sax->parse_error(m_lexer.get_position(),
10505  exception_message(token_type::end_array, "array")));
10506  }
10507  else // object
10508  {
10509  // comma -> next value
10510  if (get_token() == token_type::value_separator)
10511  {
10512  // parse key
10513  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::value_string))
10514  {
10515  return sax->parse_error(m_lexer.get_position(),
10518  exception_message(token_type::value_string, "object key")));
10519  }
10520 
10521  if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
10522  {
10523  return false;
10524  }
10525 
10526  // parse separator (:)
10527  if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
10528  {
10529  return sax->parse_error(m_lexer.get_position(),
10532  exception_message(token_type::name_separator, "object separator")));
10533  }
10534 
10535  // parse values
10536  get_token();
10537  continue;
10538  }
10539 
10540  // closing }
10541  if (JSON_HEDLEY_LIKELY(last_token == token_type::end_object))
10542  {
10543  if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
10544  {
10545  return false;
10546  }
10547 
10548  // We are done with this object. Before we can parse a
10549  // new value, we need to evaluate the new state first.
10550  // By setting skip_to_state_evaluation to false, we
10551  // are effectively jumping to the beginning of this if.
10552  JSON_ASSERT(!states.empty());
10553  states.pop_back();
10554  skip_to_state_evaluation = true;
10555  continue;
10556  }
10557 
10558  return sax->parse_error(m_lexer.get_position(),
10561  exception_message(token_type::end_object, "object")));
10562  }
10563  }
10564  }
10565 
10566  /// get next token from lexer
10567  token_type get_token()
10568  {
10569  return last_token = m_lexer.scan();
10570  }
10571 
10572  std::string exception_message(const token_type expected, const std::string& context)
10573  {
10574  std::string error_msg = "syntax error ";
10575 
10576  if (!context.empty())
10577  {
10578  error_msg += "while parsing " + context + " ";
10579  }
10580 
10581  error_msg += "- ";
10582 
10583  if (last_token == token_type::parse_error)
10584  {
10585  error_msg += std::string(m_lexer.get_error_message()) + "; last read: '" +
10586  m_lexer.get_token_string() + "'";
10587  }
10588  else
10589  {
10590  error_msg += "unexpected " + std::string(lexer_t::token_type_name(last_token));
10591  }
10592 
10593  if (expected != token_type::uninitialized)
10594  {
10595  error_msg += "; expected " + std::string(lexer_t::token_type_name(expected));
10596  }
10597 
10598  return error_msg;
10599  }
10600 
10601  private:
10602  /// callback function
10603  const parser_callback_t<BasicJsonType> callback = nullptr;
10604  /// the type of the last read token
10605  token_type last_token = token_type::uninitialized;
10606  /// the lexer
10608  /// whether to throw exceptions in case of errors
10609  const bool allow_exceptions = true;
10610 };
10611 } // namespace detail
10612 } // namespace nlohmann
10613 
10614 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
10615 
10616 
10617 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
10618 
10619 
10620 #include <cstddef> // ptrdiff_t
10621 #include <limits> // numeric_limits
10622 
10623 namespace nlohmann
10624 {
10625 namespace detail
10626 {
10627 /*
10628 @brief an iterator for primitive JSON types
10629 
10630 This class models an iterator for primitive JSON types (boolean, number,
10631 string). It's only purpose is to allow the iterator/const_iterator classes
10632 to "iterate" over primitive values. Internally, the iterator is modeled by
10633 a `difference_type` variable. Value begin_value (`0`) models the begin,
10634 end_value (`1`) models past the end.
10635 */
10637 {
10638  private:
10639  using difference_type = std::ptrdiff_t;
10640  static constexpr difference_type begin_value = 0;
10641  static constexpr difference_type end_value = begin_value + 1;
10642 
10643  /// iterator as signed integer type
10644  difference_type m_it = (std::numeric_limits<std::ptrdiff_t>::min)();
10645 
10646  public:
10647  constexpr difference_type get_value() const noexcept
10648  {
10649  return m_it;
10650  }
10651 
10652  /// set iterator to a defined beginning
10653  void set_begin() noexcept
10654  {
10655  m_it = begin_value;
10656  }
10657 
10658  /// set iterator to a defined past the end
10659  void set_end() noexcept
10660  {
10661  m_it = end_value;
10662  }
10663 
10664  /// return whether the iterator can be dereferenced
10665  constexpr bool is_begin() const noexcept
10666  {
10667  return m_it == begin_value;
10668  }
10669 
10670  /// return whether the iterator is at end
10671  constexpr bool is_end() const noexcept
10672  {
10673  return m_it == end_value;
10674  }
10675 
10676  friend constexpr bool operator==(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
10677  {
10678  return lhs.m_it == rhs.m_it;
10679  }
10680 
10681  friend constexpr bool operator<(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
10682  {
10683  return lhs.m_it < rhs.m_it;
10684  }
10685 
10686  primitive_iterator_t operator+(difference_type n) noexcept
10687  {
10688  auto result = *this;
10689  result += n;
10690  return result;
10691  }
10692 
10693  friend constexpr difference_type operator-(primitive_iterator_t lhs, primitive_iterator_t rhs) noexcept
10694  {
10695  return lhs.m_it - rhs.m_it;
10696  }
10697 
10698  primitive_iterator_t& operator++() noexcept
10699  {
10700  ++m_it;
10701  return *this;
10702  }
10703 
10704  primitive_iterator_t const operator++(int) noexcept
10705  {
10706  auto result = *this;
10707  ++m_it;
10708  return result;
10709  }
10710 
10711  primitive_iterator_t& operator--() noexcept
10712  {
10713  --m_it;
10714  return *this;
10715  }
10716 
10717  primitive_iterator_t const operator--(int) noexcept
10718  {
10719  auto result = *this;
10720  --m_it;
10721  return result;
10722  }
10723 
10724  primitive_iterator_t& operator+=(difference_type n) noexcept
10725  {
10726  m_it += n;
10727  return *this;
10728  }
10729 
10730  primitive_iterator_t& operator-=(difference_type n) noexcept
10731  {
10732  m_it -= n;
10733  return *this;
10734  }
10735 };
10736 } // namespace detail
10737 } // namespace nlohmann
10738 
10739 
10740 namespace nlohmann
10741 {
10742 namespace detail
10743 {
10744 /*!
10745 @brief an iterator value
10746 
10747 @note This structure could easily be a union, but MSVC currently does not allow
10748 unions members with complex constructors, see https://github.com/nlohmann/json/pull/105.
10749 */
10750 template<typename BasicJsonType> struct internal_iterator
10751 {
10752  /// iterator for JSON objects
10753  typename BasicJsonType::object_t::iterator object_iterator {};
10754  /// iterator for JSON arrays
10755  typename BasicJsonType::array_t::iterator array_iterator {};
10756  /// generic iterator for all other types
10758 };
10759 } // namespace detail
10760 } // namespace nlohmann
10761 
10762 // #include <nlohmann/detail/iterators/iter_impl.hpp>
10763 
10764 
10765 #include <iterator> // iterator, random_access_iterator_tag, bidirectional_iterator_tag, advance, next
10766 #include <type_traits> // conditional, is_const, remove_const
10767 
10768 // #include <nlohmann/detail/exceptions.hpp>
10769 
10770 // #include <nlohmann/detail/iterators/internal_iterator.hpp>
10771 
10772 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
10773 
10774 // #include <nlohmann/detail/macro_scope.hpp>
10775 
10776 // #include <nlohmann/detail/meta/cpp_future.hpp>
10777 
10778 // #include <nlohmann/detail/meta/type_traits.hpp>
10779 
10780 // #include <nlohmann/detail/value_t.hpp>
10781 
10782 
10783 namespace nlohmann
10784 {
10785 namespace detail
10786 {
10787 // forward declare, to be able to friend it later on
10788 template<typename IteratorType> class iteration_proxy;
10789 template<typename IteratorType> class iteration_proxy_value;
10790 
10791 /*!
10792 @brief a template for a bidirectional iterator for the @ref basic_json class
10793 This class implements a both iterators (iterator and const_iterator) for the
10794 @ref basic_json class.
10795 @note An iterator is called *initialized* when a pointer to a JSON value has
10796  been set (e.g., by a constructor or a copy assignment). If the iterator is
10797  default-constructed, it is *uninitialized* and most methods are undefined.
10798  **The library uses assertions to detect calls on uninitialized iterators.**
10799 @requirement The class satisfies the following concept requirements:
10800 -
10801 [BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
10802  The iterator that can be moved can be moved in both directions (i.e.
10803  incremented and decremented).
10804 @since version 1.0.0, simplified in version 2.0.9, change to bidirectional
10805  iterators in version 3.0.0 (see https://github.com/nlohmann/json/issues/593)
10806 */
10807 template<typename BasicJsonType>
10809 {
10810  /// allow basic_json to access private members
10811  friend iter_impl<typename std::conditional<std::is_const<BasicJsonType>::value, typename std::remove_const<BasicJsonType>::type, const BasicJsonType>::type>;
10812  friend BasicJsonType;
10815 
10816  using object_t = typename BasicJsonType::object_t;
10817  using array_t = typename BasicJsonType::array_t;
10818  // make sure BasicJsonType is basic_json or const basic_json
10819  static_assert(is_basic_json<typename std::remove_const<BasicJsonType>::type>::value,
10820  "iter_impl only accepts (const) basic_json");
10821 
10822  public:
10823 
10824  /// The std::iterator class template (used as a base class to provide typedefs) is deprecated in C++17.
10825  /// The C++ Standard has never required user-defined iterators to derive from std::iterator.
10826  /// A user-defined iterator should provide publicly accessible typedefs named
10827  /// iterator_category, value_type, difference_type, pointer, and reference.
10828  /// Note that value_type is required to be non-const, even for constant iterators.
10829  using iterator_category = std::bidirectional_iterator_tag;
10830 
10831  /// the type of the values when the iterator is dereferenced
10832  using value_type = typename BasicJsonType::value_type;
10833  /// a type to represent differences between iterators
10834  using difference_type = typename BasicJsonType::difference_type;
10835  /// defines a pointer to the type iterated over (value_type)
10836  using pointer = typename std::conditional<std::is_const<BasicJsonType>::value,
10837  typename BasicJsonType::const_pointer,
10838  typename BasicJsonType::pointer>::type;
10839  /// defines a reference to the type iterated over (value_type)
10840  using reference =
10841  typename std::conditional<std::is_const<BasicJsonType>::value,
10842  typename BasicJsonType::const_reference,
10843  typename BasicJsonType::reference>::type;
10844 
10845  /// default constructor
10846  iter_impl() = default;
10847 
10848  /*!
10849  @brief constructor for a given JSON instance
10850  @param[in] object pointer to a JSON object for this iterator
10851  @pre object != nullptr
10852  @post The iterator is initialized; i.e. `m_object != nullptr`.
10853  */
10854  explicit iter_impl(pointer object) noexcept : m_object(object)
10855  {
10856  JSON_ASSERT(m_object != nullptr);
10857 
10858  switch (m_object->m_type)
10859  {
10860  case value_t::object:
10861  {
10862  m_it.object_iterator = typename object_t::iterator();
10863  break;
10864  }
10865 
10866  case value_t::array:
10867  {
10868  m_it.array_iterator = typename array_t::iterator();
10869  break;
10870  }
10871 
10872  default:
10873  {
10875  break;
10876  }
10877  }
10878  }
10879 
10880  /*!
10881  @note The conventional copy constructor and copy assignment are implicitly
10882  defined. Combined with the following converting constructor and
10883  assignment, they support: (1) copy from iterator to iterator, (2)
10884  copy from const iterator to const iterator, and (3) conversion from
10885  iterator to const iterator. However conversion from const iterator
10886  to iterator is not defined.
10887  */
10888 
10889  /*!
10890  @brief const copy constructor
10891  @param[in] other const iterator to copy from
10892  @note This copy constructor had to be defined explicitly to circumvent a bug
10893  occurring on msvc v19.0 compiler (VS 2015) debug build. For more
10894  information refer to: https://github.com/nlohmann/json/issues/1608
10895  */
10897  : m_object(other.m_object), m_it(other.m_it)
10898  {}
10899 
10900  /*!
10901  @brief converting assignment
10902  @param[in] other const iterator to copy from
10903  @return const/non-const iterator
10904  @note It is not checked whether @a other is initialized.
10905  */
10907  {
10908  m_object = other.m_object;
10909  m_it = other.m_it;
10910  return *this;
10911  }
10912 
10913  /*!
10914  @brief converting constructor
10915  @param[in] other non-const iterator to copy from
10916  @note It is not checked whether @a other is initialized.
10917  */
10918  iter_impl(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
10919  : m_object(other.m_object), m_it(other.m_it)
10920  {}
10921 
10922  /*!
10923  @brief converting assignment
10924  @param[in] other non-const iterator to copy from
10925  @return const/non-const iterator
10926  @note It is not checked whether @a other is initialized.
10927  */
10928  iter_impl& operator=(const iter_impl<typename std::remove_const<BasicJsonType>::type>& other) noexcept
10929  {
10930  m_object = other.m_object;
10931  m_it = other.m_it;
10932  return *this;
10933  }
10934 
10935  private:
10936  /*!
10937  @brief set the iterator to the first value
10938  @pre The iterator is initialized; i.e. `m_object != nullptr`.
10939  */
10940  void set_begin() noexcept
10941  {
10942  JSON_ASSERT(m_object != nullptr);
10943 
10944  switch (m_object->m_type)
10945  {
10946  case value_t::object:
10947  {
10948  m_it.object_iterator = m_object->m_value.object->begin();
10949  break;
10950  }
10951 
10952  case value_t::array:
10953  {
10954  m_it.array_iterator = m_object->m_value.array->begin();
10955  break;
10956  }
10957 
10958  case value_t::null:
10959  {
10960  // set to end so begin()==end() is true: null is empty
10962  break;
10963  }
10964 
10965  default:
10966  {
10968  break;
10969  }
10970  }
10971  }
10972 
10973  /*!
10974  @brief set the iterator past the last value
10975  @pre The iterator is initialized; i.e. `m_object != nullptr`.
10976  */
10977  void set_end() noexcept
10978  {
10979  JSON_ASSERT(m_object != nullptr);
10980 
10981  switch (m_object->m_type)
10982  {
10983  case value_t::object:
10984  {
10985  m_it.object_iterator = m_object->m_value.object->end();
10986  break;
10987  }
10988 
10989  case value_t::array:
10990  {
10991  m_it.array_iterator = m_object->m_value.array->end();
10992  break;
10993  }
10994 
10995  default:
10996  {
10998  break;
10999  }
11000  }
11001  }
11002 
11003  public:
11004  /*!
11005  @brief return a reference to the value pointed to by the iterator
11006  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11007  */
11009  {
11010  JSON_ASSERT(m_object != nullptr);
11011 
11012  switch (m_object->m_type)
11013  {
11014  case value_t::object:
11015  {
11016  JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11017  return m_it.object_iterator->second;
11018  }
11019 
11020  case value_t::array:
11021  {
11022  JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11023  return *m_it.array_iterator;
11024  }
11025 
11026  case value_t::null:
11027  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
11028 
11029  default:
11030  {
11031  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11032  {
11033  return *m_object;
11034  }
11035 
11036  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
11037  }
11038  }
11039  }
11040 
11041  /*!
11042  @brief dereference the iterator
11043  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11044  */
11046  {
11047  JSON_ASSERT(m_object != nullptr);
11048 
11049  switch (m_object->m_type)
11050  {
11051  case value_t::object:
11052  {
11053  JSON_ASSERT(m_it.object_iterator != m_object->m_value.object->end());
11054  return &(m_it.object_iterator->second);
11055  }
11056 
11057  case value_t::array:
11058  {
11059  JSON_ASSERT(m_it.array_iterator != m_object->m_value.array->end());
11060  return &*m_it.array_iterator;
11061  }
11062 
11063  default:
11064  {
11065  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.is_begin()))
11066  {
11067  return m_object;
11068  }
11069 
11070  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
11071  }
11072  }
11073  }
11074 
11075  /*!
11076  @brief post-increment (it++)
11077  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11078  */
11080  {
11081  auto result = *this;
11082  ++(*this);
11083  return result;
11084  }
11085 
11086  /*!
11087  @brief pre-increment (++it)
11088  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11089  */
11091  {
11092  JSON_ASSERT(m_object != nullptr);
11093 
11094  switch (m_object->m_type)
11095  {
11096  case value_t::object:
11097  {
11098  std::advance(m_it.object_iterator, 1);
11099  break;
11100  }
11101 
11102  case value_t::array:
11103  {
11104  std::advance(m_it.array_iterator, 1);
11105  break;
11106  }
11107 
11108  default:
11109  {
11111  break;
11112  }
11113  }
11114 
11115  return *this;
11116  }
11117 
11118  /*!
11119  @brief post-decrement (it--)
11120  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11121  */
11123  {
11124  auto result = *this;
11125  --(*this);
11126  return result;
11127  }
11128 
11129  /*!
11130  @brief pre-decrement (--it)
11131  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11132  */
11134  {
11135  JSON_ASSERT(m_object != nullptr);
11136 
11137  switch (m_object->m_type)
11138  {
11139  case value_t::object:
11140  {
11141  std::advance(m_it.object_iterator, -1);
11142  break;
11143  }
11144 
11145  case value_t::array:
11146  {
11147  std::advance(m_it.array_iterator, -1);
11148  break;
11149  }
11150 
11151  default:
11152  {
11154  break;
11155  }
11156  }
11157 
11158  return *this;
11159  }
11160 
11161  /*!
11162  @brief comparison: equal
11163  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11164  */
11165  bool operator==(const iter_impl& other) const
11166  {
11167  // if objects are not the same, the comparison is undefined
11168  if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11169  {
11170  JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
11171  }
11172 
11173  JSON_ASSERT(m_object != nullptr);
11174 
11175  switch (m_object->m_type)
11176  {
11177  case value_t::object:
11178  return (m_it.object_iterator == other.m_it.object_iterator);
11179 
11180  case value_t::array:
11181  return (m_it.array_iterator == other.m_it.array_iterator);
11182 
11183  default:
11184  return (m_it.primitive_iterator == other.m_it.primitive_iterator);
11185  }
11186  }
11187 
11188  /*!
11189  @brief comparison: not equal
11190  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11191  */
11192  bool operator!=(const iter_impl& other) const
11193  {
11194  return !operator==(other);
11195  }
11196 
11197  /*!
11198  @brief comparison: smaller
11199  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11200  */
11201  bool operator<(const iter_impl& other) const
11202  {
11203  // if objects are not the same, the comparison is undefined
11204  if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
11205  {
11206  JSON_THROW(invalid_iterator::create(212, "cannot compare iterators of different containers"));
11207  }
11208 
11209  JSON_ASSERT(m_object != nullptr);
11210 
11211  switch (m_object->m_type)
11212  {
11213  case value_t::object:
11214  JSON_THROW(invalid_iterator::create(213, "cannot compare order of object iterators"));
11215 
11216  case value_t::array:
11217  return (m_it.array_iterator < other.m_it.array_iterator);
11218 
11219  default:
11221  }
11222  }
11223 
11224  /*!
11225  @brief comparison: less than or equal
11226  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11227  */
11228  bool operator<=(const iter_impl& other) const
11229  {
11230  return !other.operator < (*this);
11231  }
11232 
11233  /*!
11234  @brief comparison: greater than
11235  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11236  */
11237  bool operator>(const iter_impl& other) const
11238  {
11239  return !operator<=(other);
11240  }
11241 
11242  /*!
11243  @brief comparison: greater than or equal
11244  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11245  */
11246  bool operator>=(const iter_impl& other) const
11247  {
11248  return !operator<(other);
11249  }
11250 
11251  /*!
11252  @brief add to iterator
11253  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11254  */
11256  {
11257  JSON_ASSERT(m_object != nullptr);
11258 
11259  switch (m_object->m_type)
11260  {
11261  case value_t::object:
11262  JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
11263 
11264  case value_t::array:
11265  {
11266  std::advance(m_it.array_iterator, i);
11267  break;
11268  }
11269 
11270  default:
11271  {
11272  m_it.primitive_iterator += i;
11273  break;
11274  }
11275  }
11276 
11277  return *this;
11278  }
11279 
11280  /*!
11281  @brief subtract from iterator
11282  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11283  */
11285  {
11286  return operator+=(-i);
11287  }
11288 
11289  /*!
11290  @brief add to iterator
11291  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11292  */
11294  {
11295  auto result = *this;
11296  result += i;
11297  return result;
11298  }
11299 
11300  /*!
11301  @brief addition of distance and iterator
11302  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11303  */
11305  {
11306  auto result = it;
11307  result += i;
11308  return result;
11309  }
11310 
11311  /*!
11312  @brief subtract from iterator
11313  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11314  */
11316  {
11317  auto result = *this;
11318  result -= i;
11319  return result;
11320  }
11321 
11322  /*!
11323  @brief return difference
11324  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11325  */
11327  {
11328  JSON_ASSERT(m_object != nullptr);
11329 
11330  switch (m_object->m_type)
11331  {
11332  case value_t::object:
11333  JSON_THROW(invalid_iterator::create(209, "cannot use offsets with object iterators"));
11334 
11335  case value_t::array:
11336  return m_it.array_iterator - other.m_it.array_iterator;
11337 
11338  default:
11340  }
11341  }
11342 
11343  /*!
11344  @brief access to successor
11345  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11346  */
11348  {
11349  JSON_ASSERT(m_object != nullptr);
11350 
11351  switch (m_object->m_type)
11352  {
11353  case value_t::object:
11354  JSON_THROW(invalid_iterator::create(208, "cannot use operator[] for object iterators"));
11355 
11356  case value_t::array:
11357  return *std::next(m_it.array_iterator, n);
11358 
11359  case value_t::null:
11360  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
11361 
11362  default:
11363  {
11364  if (JSON_HEDLEY_LIKELY(m_it.primitive_iterator.get_value() == -n))
11365  {
11366  return *m_object;
11367  }
11368 
11369  JSON_THROW(invalid_iterator::create(214, "cannot get value"));
11370  }
11371  }
11372  }
11373 
11374  /*!
11375  @brief return the key of an object iterator
11376  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11377  */
11378  const typename object_t::key_type& key() const
11379  {
11380  JSON_ASSERT(m_object != nullptr);
11381 
11382  if (JSON_HEDLEY_LIKELY(m_object->is_object()))
11383  {
11384  return m_it.object_iterator->first;
11385  }
11386 
11387  JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
11388  }
11389 
11390  /*!
11391  @brief return the value of an iterator
11392  @pre The iterator is initialized; i.e. `m_object != nullptr`.
11393  */
11395  {
11396  return operator*();
11397  }
11398 
11399  private:
11400  /// associated JSON instance
11401  pointer m_object = nullptr;
11402  /// the actual iterator of the associated instance
11404 };
11405 } // namespace detail
11406 } // namespace nlohmann
11407 
11408 // #include <nlohmann/detail/iterators/iteration_proxy.hpp>
11409 
11410 // #include <nlohmann/detail/iterators/json_reverse_iterator.hpp>
11411 
11412 
11413 #include <cstddef> // ptrdiff_t
11414 #include <iterator> // reverse_iterator
11415 #include <utility> // declval
11416 
11417 namespace nlohmann
11418 {
11419 namespace detail
11420 {
11421 //////////////////////
11422 // reverse_iterator //
11423 //////////////////////
11424 
11425 /*!
11426 @brief a template for a reverse iterator class
11427 
11428 @tparam Base the base iterator type to reverse. Valid types are @ref
11429 iterator (to create @ref reverse_iterator) and @ref const_iterator (to
11430 create @ref const_reverse_iterator).
11431 
11432 @requirement The class satisfies the following concept requirements:
11433 -
11434 [BidirectionalIterator](https://en.cppreference.com/w/cpp/named_req/BidirectionalIterator):
11435  The iterator that can be moved can be moved in both directions (i.e.
11436  incremented and decremented).
11437 - [OutputIterator](https://en.cppreference.com/w/cpp/named_req/OutputIterator):
11438  It is possible to write to the pointed-to element (only if @a Base is
11439  @ref iterator).
11440 
11441 @since version 1.0.0
11442 */
11443 template<typename Base>
11444 class json_reverse_iterator : public std::reverse_iterator<Base>
11445 {
11446  public:
11447  using difference_type = std::ptrdiff_t;
11448  /// shortcut to the reverse iterator adapter
11449  using base_iterator = std::reverse_iterator<Base>;
11450  /// the reference type for the pointed-to element
11451  using reference = typename Base::reference;
11452 
11453  /// create reverse iterator from iterator
11454  explicit json_reverse_iterator(const typename base_iterator::iterator_type& it) noexcept
11455  : base_iterator(it) {}
11456 
11457  /// create reverse iterator from base class
11458  explicit json_reverse_iterator(const base_iterator& it) noexcept : base_iterator(it) {}
11459 
11460  /// post-increment (it++)
11462  {
11463  return static_cast<json_reverse_iterator>(base_iterator::operator++(1));
11464  }
11465 
11466  /// pre-increment (++it)
11468  {
11469  return static_cast<json_reverse_iterator&>(base_iterator::operator++());
11470  }
11471 
11472  /// post-decrement (it--)
11474  {
11475  return static_cast<json_reverse_iterator>(base_iterator::operator--(1));
11476  }
11477 
11478  /// pre-decrement (--it)
11480  {
11481  return static_cast<json_reverse_iterator&>(base_iterator::operator--());
11482  }
11483 
11484  /// add to iterator
11485  json_reverse_iterator& operator+=(difference_type i)
11486  {
11487  return static_cast<json_reverse_iterator&>(base_iterator::operator+=(i));
11488  }
11489 
11490  /// add to iterator
11491  json_reverse_iterator operator+(difference_type i) const
11492  {
11493  return static_cast<json_reverse_iterator>(base_iterator::operator+(i));
11494  }
11495 
11496  /// subtract from iterator
11497  json_reverse_iterator operator-(difference_type i) const
11498  {
11499  return static_cast<json_reverse_iterator>(base_iterator::operator-(i));
11500  }
11501 
11502  /// return difference
11503  difference_type operator-(const json_reverse_iterator& other) const
11504  {
11505  return base_iterator(*this) - base_iterator(other);
11506  }
11507 
11508  /// access to successor
11509  reference operator[](difference_type n) const
11510  {
11511  return *(this->operator+(n));
11512  }
11513 
11514  /// return the key of an object iterator
11515  auto key() const -> decltype(std::declval<Base>().key())
11516  {
11517  auto it = --this->base();
11518  return it.key();
11519  }
11520 
11521  /// return the value of an iterator
11523  {
11524  auto it = --this->base();
11525  return it.operator * ();
11526  }
11527 };
11528 } // namespace detail
11529 } // namespace nlohmann
11530 
11531 // #include <nlohmann/detail/iterators/primitive_iterator.hpp>
11532 
11533 // #include <nlohmann/detail/json_pointer.hpp>
11534 
11535 
11536 #include <algorithm> // all_of
11537 #include <cctype> // isdigit
11538 #include <limits> // max
11539 #include <numeric> // accumulate
11540 #include <string> // string
11541 #include <utility> // move
11542 #include <vector> // vector
11543 
11544 // #include <nlohmann/detail/exceptions.hpp>
11545 
11546 // #include <nlohmann/detail/macro_scope.hpp>
11547 
11548 // #include <nlohmann/detail/value_t.hpp>
11549 
11550 
11551 namespace nlohmann
11552 {
11553 template<typename BasicJsonType>
11555 {
11556  // allow basic_json to access private members
11557  NLOHMANN_BASIC_JSON_TPL_DECLARATION
11558  friend class basic_json;
11559 
11560  public:
11561  /*!
11562  @brief create JSON pointer
11563 
11564  Create a JSON pointer according to the syntax described in
11565  [Section 3 of RFC6901](https://tools.ietf.org/html/rfc6901#section-3).
11566 
11567  @param[in] s string representing the JSON pointer; if omitted, the empty
11568  string is assumed which references the whole JSON value
11569 
11570  @throw parse_error.107 if the given JSON pointer @a s is nonempty and does
11571  not begin with a slash (`/`); see example below
11572 
11573  @throw parse_error.108 if a tilde (`~`) in the given JSON pointer @a s is
11574  not followed by `0` (representing `~`) or `1` (representing `/`); see
11575  example below
11576 
11577  @liveexample{The example shows the construction several valid JSON pointers
11578  as well as the exceptional behavior.,json_pointer}
11579 
11580  @since version 2.0.0
11581  */
11582  explicit json_pointer(const std::string& s = "")
11583  : reference_tokens(split(s))
11584  {}
11585 
11586  /*!
11587  @brief return a string representation of the JSON pointer
11588 
11589  @invariant For each JSON pointer `ptr`, it holds:
11590  @code {.cpp}
11591  ptr == json_pointer(ptr.to_string());
11592  @endcode
11593 
11594  @return a string representation of the JSON pointer
11595 
11596  @liveexample{The example shows the result of `to_string`.,json_pointer__to_string}
11597 
11598  @since version 2.0.0
11599  */
11600  std::string to_string() const
11601  {
11602  return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
11603  std::string{},
11604  [](const std::string & a, const std::string & b)
11605  {
11606  return a + "/" + escape(b);
11607  });
11608  }
11609 
11610  /// @copydoc to_string()
11611  operator std::string() const
11612  {
11613  return to_string();
11614  }
11615 
11616  /*!
11617  @brief append another JSON pointer at the end of this JSON pointer
11618 
11619  @param[in] ptr JSON pointer to append
11620  @return JSON pointer with @a ptr appended
11621 
11622  @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
11623 
11624  @complexity Linear in the length of @a ptr.
11625 
11626  @sa @ref operator/=(std::string) to append a reference token
11627  @sa @ref operator/=(std::size_t) to append an array index
11628  @sa @ref operator/(const json_pointer&, const json_pointer&) for a binary operator
11629 
11630  @since version 3.6.0
11631  */
11633  {
11634  reference_tokens.insert(reference_tokens.end(),
11635  ptr.reference_tokens.begin(),
11636  ptr.reference_tokens.end());
11637  return *this;
11638  }
11639 
11640  /*!
11641  @brief append an unescaped reference token at the end of this JSON pointer
11642 
11643  @param[in] token reference token to append
11644  @return JSON pointer with @a token appended without escaping @a token
11645 
11646  @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
11647 
11648  @complexity Amortized constant.
11649 
11650  @sa @ref operator/=(const json_pointer&) to append a JSON pointer
11651  @sa @ref operator/=(std::size_t) to append an array index
11652  @sa @ref operator/(const json_pointer&, std::size_t) for a binary operator
11653 
11654  @since version 3.6.0
11655  */
11656  json_pointer& operator/=(std::string token)
11657  {
11658  push_back(std::move(token));
11659  return *this;
11660  }
11661 
11662  /*!
11663  @brief append an array index at the end of this JSON pointer
11664 
11665  @param[in] array_idx array index to append
11666  @return JSON pointer with @a array_idx appended
11667 
11668  @liveexample{The example shows the usage of `operator/=`.,json_pointer__operator_add}
11669 
11670  @complexity Amortized constant.
11671 
11672  @sa @ref operator/=(const json_pointer&) to append a JSON pointer
11673  @sa @ref operator/=(std::string) to append a reference token
11674  @sa @ref operator/(const json_pointer&, std::string) for a binary operator
11675 
11676  @since version 3.6.0
11677  */
11678  json_pointer& operator/=(std::size_t array_idx)
11679  {
11680  return *this /= std::to_string(array_idx);
11681  }
11682 
11683  /*!
11684  @brief create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
11685 
11686  @param[in] lhs JSON pointer
11687  @param[in] rhs JSON pointer
11688  @return a new JSON pointer with @a rhs appended to @a lhs
11689 
11690  @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
11691 
11692  @complexity Linear in the length of @a lhs and @a rhs.
11693 
11694  @sa @ref operator/=(const json_pointer&) to append a JSON pointer
11695 
11696  @since version 3.6.0
11697  */
11699  const json_pointer& rhs)
11700  {
11701  return json_pointer(lhs) /= rhs;
11702  }
11703 
11704  /*!
11705  @brief create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
11706 
11707  @param[in] ptr JSON pointer
11708  @param[in] token reference token
11709  @return a new JSON pointer with unescaped @a token appended to @a ptr
11710 
11711  @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
11712 
11713  @complexity Linear in the length of @a ptr.
11714 
11715  @sa @ref operator/=(std::string) to append a reference token
11716 
11717  @since version 3.6.0
11718  */
11719  friend json_pointer operator/(const json_pointer& ptr, std::string token)
11720  {
11721  return json_pointer(ptr) /= std::move(token);
11722  }
11723 
11724  /*!
11725  @brief create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
11726 
11727  @param[in] ptr JSON pointer
11728  @param[in] array_idx array index
11729  @return a new JSON pointer with @a array_idx appended to @a ptr
11730 
11731  @liveexample{The example shows the usage of `operator/`.,json_pointer__operator_add_binary}
11732 
11733  @complexity Linear in the length of @a ptr.
11734 
11735  @sa @ref operator/=(std::size_t) to append an array index
11736 
11737  @since version 3.6.0
11738  */
11739  friend json_pointer operator/(const json_pointer& ptr, std::size_t array_idx)
11740  {
11741  return json_pointer(ptr) /= array_idx;
11742  }
11743 
11744  /*!
11745  @brief returns the parent of this JSON pointer
11746 
11747  @return parent of this JSON pointer; in case this JSON pointer is the root,
11748  the root itself is returned
11749 
11750  @complexity Linear in the length of the JSON pointer.
11751 
11752  @liveexample{The example shows the result of `parent_pointer` for different
11753  JSON Pointers.,json_pointer__parent_pointer}
11754 
11755  @since version 3.6.0
11756  */
11758  {
11759  if (empty())
11760  {
11761  return *this;
11762  }
11763 
11764  json_pointer res = *this;
11765  res.pop_back();
11766  return res;
11767  }
11768 
11769  /*!
11770  @brief remove last reference token
11771 
11772  @pre not `empty()`
11773 
11774  @liveexample{The example shows the usage of `pop_back`.,json_pointer__pop_back}
11775 
11776  @complexity Constant.
11777 
11778  @throw out_of_range.405 if JSON pointer has no parent
11779 
11780  @since version 3.6.0
11781  */
11782  void pop_back()
11783  {
11784  if (JSON_HEDLEY_UNLIKELY(empty()))
11785  {
11786  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
11787  }
11788 
11789  reference_tokens.pop_back();
11790  }
11791 
11792  /*!
11793  @brief return last reference token
11794 
11795  @pre not `empty()`
11796  @return last reference token
11797 
11798  @liveexample{The example shows the usage of `back`.,json_pointer__back}
11799 
11800  @complexity Constant.
11801 
11802  @throw out_of_range.405 if JSON pointer has no parent
11803 
11804  @since version 3.6.0
11805  */
11806  const std::string& back() const
11807  {
11808  if (JSON_HEDLEY_UNLIKELY(empty()))
11809  {
11810  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
11811  }
11812 
11813  return reference_tokens.back();
11814  }
11815 
11816  /*!
11817  @brief append an unescaped token at the end of the reference pointer
11818 
11819  @param[in] token token to add
11820 
11821  @complexity Amortized constant.
11822 
11823  @liveexample{The example shows the result of `push_back` for different
11824  JSON Pointers.,json_pointer__push_back}
11825 
11826  @since version 3.6.0
11827  */
11828  void push_back(const std::string& token)
11829  {
11830  reference_tokens.push_back(token);
11831  }
11832 
11833  /// @copydoc push_back(const std::string&)
11834  void push_back(std::string&& token)
11835  {
11836  reference_tokens.push_back(std::move(token));
11837  }
11838 
11839  /*!
11840  @brief return whether pointer points to the root document
11841 
11842  @return true iff the JSON pointer points to the root document
11843 
11844  @complexity Constant.
11845 
11846  @exceptionsafety No-throw guarantee: this function never throws exceptions.
11847 
11848  @liveexample{The example shows the result of `empty` for different JSON
11849  Pointers.,json_pointer__empty}
11850 
11851  @since version 3.6.0
11852  */
11853  bool empty() const noexcept
11854  {
11855  return reference_tokens.empty();
11856  }
11857 
11858  private:
11859  /*!
11860  @param[in] s reference token to be converted into an array index
11861 
11862  @return integer representation of @a s
11863 
11864  @throw parse_error.106 if an array index begins with '0'
11865  @throw parse_error.109 if an array index begins not with a digit
11866  @throw out_of_range.404 if string @a s could not be converted to an integer
11867  @throw out_of_range.410 if an array index exceeds size_type
11868  */
11869  static typename BasicJsonType::size_type array_index(const std::string& s)
11870  {
11871  using size_type = typename BasicJsonType::size_type;
11872 
11873  // error condition (cf. RFC 6901, Sect. 4)
11874  if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && s[0] == '0'))
11875  {
11876  JSON_THROW(detail::parse_error::create(106, 0,
11877  "array index '" + s +
11878  "' must not begin with '0'"));
11879  }
11880 
11881  // error condition (cf. RFC 6901, Sect. 4)
11882  if (JSON_HEDLEY_UNLIKELY(s.size() > 1 && !(s[0] >= '1' && s[0] <= '9')))
11883  {
11884  JSON_THROW(detail::parse_error::create(109, 0, "array index '" + s + "' is not a number"));
11885  }
11886 
11887  std::size_t processed_chars = 0;
11888  unsigned long long res = 0;
11889  JSON_TRY
11890  {
11891  res = std::stoull(s, &processed_chars);
11892  }
11893  JSON_CATCH(std::out_of_range&)
11894  {
11895  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
11896  }
11897 
11898  // check if the string was completely read
11899  if (JSON_HEDLEY_UNLIKELY(processed_chars != s.size()))
11900  {
11901  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + s + "'"));
11902  }
11903 
11904  // only triggered on special platforms (like 32bit), see also
11905  // https://github.com/nlohmann/json/pull/2203
11906  if (res >= static_cast<unsigned long long>((std::numeric_limits<size_type>::max)()))
11907  {
11908  JSON_THROW(detail::out_of_range::create(410, "array index " + s + " exceeds size_type")); // LCOV_EXCL_LINE
11909  }
11910 
11911  return static_cast<size_type>(res);
11912  }
11913 
11914  json_pointer top() const
11915  {
11916  if (JSON_HEDLEY_UNLIKELY(empty()))
11917  {
11918  JSON_THROW(detail::out_of_range::create(405, "JSON pointer has no parent"));
11919  }
11920 
11921  json_pointer result = *this;
11922  result.reference_tokens = {reference_tokens[0]};
11923  return result;
11924  }
11925 
11926  /*!
11927  @brief create and return a reference to the pointed to value
11928 
11929  @complexity Linear in the number of reference tokens.
11930 
11931  @throw parse_error.109 if array index is not a number
11932  @throw type_error.313 if value cannot be unflattened
11933  */
11934  BasicJsonType& get_and_create(BasicJsonType& j) const
11935  {
11936  auto result = &j;
11937 
11938  // in case no reference tokens exist, return a reference to the JSON value
11939  // j which will be overwritten by a primitive value
11940  for (const auto& reference_token : reference_tokens)
11941  {
11942  switch (result->type())
11943  {
11944  case detail::value_t::null:
11945  {
11946  if (reference_token == "0")
11947  {
11948  // start a new array if reference token is 0
11949  result = &result->operator[](0);
11950  }
11951  else
11952  {
11953  // start a new object otherwise
11954  result = &result->operator[](reference_token);
11955  }
11956  break;
11957  }
11958 
11960  {
11961  // create an entry in the object
11962  result = &result->operator[](reference_token);
11963  break;
11964  }
11965 
11967  {
11968  // create an entry in the array
11969  result = &result->operator[](array_index(reference_token));
11970  break;
11971  }
11972 
11973  /*
11974  The following code is only reached if there exists a reference
11975  token _and_ the current value is primitive. In this case, we have
11976  an error situation, because primitive values may only occur as
11977  single value; that is, with an empty list of reference tokens.
11978  */
11979  default:
11980  JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
11981  }
11982  }
11983 
11984  return *result;
11985  }
11986 
11987  /*!
11988  @brief return a reference to the pointed to value
11989 
11990  @note This version does not throw if a value is not present, but tries to
11991  create nested values instead. For instance, calling this function
11992  with pointer `"/this/that"` on a null value is equivalent to calling
11993  `operator[]("this").operator[]("that")` on that value, effectively
11994  changing the null value to an object.
11995 
11996  @param[in] ptr a JSON value
11997 
11998  @return reference to the JSON value pointed to by the JSON pointer
11999 
12000  @complexity Linear in the length of the JSON pointer.
12001 
12002  @throw parse_error.106 if an array index begins with '0'
12003  @throw parse_error.109 if an array index was not a number
12004  @throw out_of_range.404 if the JSON pointer can not be resolved
12005  */
12006  BasicJsonType& get_unchecked(BasicJsonType* ptr) const
12007  {
12008  for (const auto& reference_token : reference_tokens)
12009  {
12010  // convert null values to arrays or objects before continuing
12011  if (ptr->is_null())
12012  {
12013  // check if reference token is a number
12014  const bool nums =
12015  std::all_of(reference_token.begin(), reference_token.end(),
12016  [](const unsigned char x)
12017  {
12018  return std::isdigit(x);
12019  });
12020 
12021  // change value to array for numbers or "-" or to object otherwise
12022  *ptr = (nums || reference_token == "-")
12025  }
12026 
12027  switch (ptr->type())
12028  {
12030  {
12031  // use unchecked object access
12032  ptr = &ptr->operator[](reference_token);
12033  break;
12034  }
12035 
12037  {
12038  if (reference_token == "-")
12039  {
12040  // explicitly treat "-" as index beyond the end
12041  ptr = &ptr->operator[](ptr->m_value.array->size());
12042  }
12043  else
12044  {
12045  // convert array index to number; unchecked access
12046  ptr = &ptr->operator[](array_index(reference_token));
12047  }
12048  break;
12049  }
12050 
12051  default:
12052  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
12053  }
12054  }
12055 
12056  return *ptr;
12057  }
12058 
12059  /*!
12060  @throw parse_error.106 if an array index begins with '0'
12061  @throw parse_error.109 if an array index was not a number
12062  @throw out_of_range.402 if the array index '-' is used
12063  @throw out_of_range.404 if the JSON pointer can not be resolved
12064  */
12065  BasicJsonType& get_checked(BasicJsonType* ptr) const
12066  {
12067  for (const auto& reference_token : reference_tokens)
12068  {
12069  switch (ptr->type())
12070  {
12072  {
12073  // note: at performs range check
12074  ptr = &ptr->at(reference_token);
12075  break;
12076  }
12077 
12079  {
12080  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12081  {
12082  // "-" always fails the range check
12083  JSON_THROW(detail::out_of_range::create(402,
12084  "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12085  ") is out of range"));
12086  }
12087 
12088  // note: at performs range check
12089  ptr = &ptr->at(array_index(reference_token));
12090  break;
12091  }
12092 
12093  default:
12094  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
12095  }
12096  }
12097 
12098  return *ptr;
12099  }
12100 
12101  /*!
12102  @brief return a const reference to the pointed to value
12103 
12104  @param[in] ptr a JSON value
12105 
12106  @return const reference to the JSON value pointed to by the JSON
12107  pointer
12108 
12109  @throw parse_error.106 if an array index begins with '0'
12110  @throw parse_error.109 if an array index was not a number
12111  @throw out_of_range.402 if the array index '-' is used
12112  @throw out_of_range.404 if the JSON pointer can not be resolved
12113  */
12114  const BasicJsonType& get_unchecked(const BasicJsonType* ptr) const
12115  {
12116  for (const auto& reference_token : reference_tokens)
12117  {
12118  switch (ptr->type())
12119  {
12121  {
12122  // use unchecked object access
12123  ptr = &ptr->operator[](reference_token);
12124  break;
12125  }
12126 
12128  {
12129  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12130  {
12131  // "-" cannot be used for const access
12132  JSON_THROW(detail::out_of_range::create(402,
12133  "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12134  ") is out of range"));
12135  }
12136 
12137  // use unchecked array access
12138  ptr = &ptr->operator[](array_index(reference_token));
12139  break;
12140  }
12141 
12142  default:
12143  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
12144  }
12145  }
12146 
12147  return *ptr;
12148  }
12149 
12150  /*!
12151  @throw parse_error.106 if an array index begins with '0'
12152  @throw parse_error.109 if an array index was not a number
12153  @throw out_of_range.402 if the array index '-' is used
12154  @throw out_of_range.404 if the JSON pointer can not be resolved
12155  */
12156  const BasicJsonType& get_checked(const BasicJsonType* ptr) const
12157  {
12158  for (const auto& reference_token : reference_tokens)
12159  {
12160  switch (ptr->type())
12161  {
12163  {
12164  // note: at performs range check
12165  ptr = &ptr->at(reference_token);
12166  break;
12167  }
12168 
12170  {
12171  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12172  {
12173  // "-" always fails the range check
12174  JSON_THROW(detail::out_of_range::create(402,
12175  "array index '-' (" + std::to_string(ptr->m_value.array->size()) +
12176  ") is out of range"));
12177  }
12178 
12179  // note: at performs range check
12180  ptr = &ptr->at(array_index(reference_token));
12181  break;
12182  }
12183 
12184  default:
12185  JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
12186  }
12187  }
12188 
12189  return *ptr;
12190  }
12191 
12192  /*!
12193  @throw parse_error.106 if an array index begins with '0'
12194  @throw parse_error.109 if an array index was not a number
12195  */
12196  bool contains(const BasicJsonType* ptr) const
12197  {
12198  for (const auto& reference_token : reference_tokens)
12199  {
12200  switch (ptr->type())
12201  {
12203  {
12204  if (!ptr->contains(reference_token))
12205  {
12206  // we did not find the key in the object
12207  return false;
12208  }
12209 
12210  ptr = &ptr->operator[](reference_token);
12211  break;
12212  }
12213 
12215  {
12216  if (JSON_HEDLEY_UNLIKELY(reference_token == "-"))
12217  {
12218  // "-" always fails the range check
12219  return false;
12220  }
12221  if (JSON_HEDLEY_UNLIKELY(reference_token.size() == 1 && !("0" <= reference_token && reference_token <= "9")))
12222  {
12223  // invalid char
12224  return false;
12225  }
12226  if (JSON_HEDLEY_UNLIKELY(reference_token.size() > 1))
12227  {
12228  if (JSON_HEDLEY_UNLIKELY(!('1' <= reference_token[0] && reference_token[0] <= '9')))
12229  {
12230  // first char should be between '1' and '9'
12231  return false;
12232  }
12233  for (std::size_t i = 1; i < reference_token.size(); i++)
12234  {
12235  if (JSON_HEDLEY_UNLIKELY(!('0' <= reference_token[i] && reference_token[i] <= '9')))
12236  {
12237  // other char should be between '0' and '9'
12238  return false;
12239  }
12240  }
12241  }
12242 
12243  const auto idx = array_index(reference_token);
12244  if (idx >= ptr->size())
12245  {
12246  // index out of range
12247  return false;
12248  }
12249 
12250  ptr = &ptr->operator[](idx);
12251  break;
12252  }
12253 
12254  default:
12255  {
12256  // we do not expect primitive values if there is still a
12257  // reference token to process
12258  return false;
12259  }
12260  }
12261  }
12262 
12263  // no reference token left means we found a primitive value
12264  return true;
12265  }
12266 
12267  /*!
12268  @brief split the string input to reference tokens
12269 
12270  @note This function is only called by the json_pointer constructor.
12271  All exceptions below are documented there.
12272 
12273  @throw parse_error.107 if the pointer is not empty or begins with '/'
12274  @throw parse_error.108 if character '~' is not followed by '0' or '1'
12275  */
12276  static std::vector<std::string> split(const std::string& reference_string)
12277  {
12278  std::vector<std::string> result;
12279 
12280  // special case: empty reference string -> no reference tokens
12281  if (reference_string.empty())
12282  {
12283  return result;
12284  }
12285 
12286  // check if nonempty reference string begins with slash
12287  if (JSON_HEDLEY_UNLIKELY(reference_string[0] != '/'))
12288  {
12289  JSON_THROW(detail::parse_error::create(107, 1,
12290  "JSON pointer must be empty or begin with '/' - was: '" +
12291  reference_string + "'"));
12292  }
12293 
12294  // extract the reference tokens:
12295  // - slash: position of the last read slash (or end of string)
12296  // - start: position after the previous slash
12297  for (
12298  // search for the first slash after the first character
12299  std::size_t slash = reference_string.find_first_of('/', 1),
12300  // set the beginning of the first reference token
12301  start = 1;
12302  // we can stop if start == 0 (if slash == std::string::npos)
12303  start != 0;
12304  // set the beginning of the next reference token
12305  // (will eventually be 0 if slash == std::string::npos)
12306  start = (slash == std::string::npos) ? 0 : slash + 1,
12307  // find next slash
12308  slash = reference_string.find_first_of('/', start))
12309  {
12310  // use the text between the beginning of the reference token
12311  // (start) and the last slash (slash).
12312  auto reference_token = reference_string.substr(start, slash - start);
12313 
12314  // check reference tokens are properly escaped
12315  for (std::size_t pos = reference_token.find_first_of('~');
12316  pos != std::string::npos;
12317  pos = reference_token.find_first_of('~', pos + 1))
12318  {
12319  JSON_ASSERT(reference_token[pos] == '~');
12320 
12321  // ~ must be followed by 0 or 1
12322  if (JSON_HEDLEY_UNLIKELY(pos == reference_token.size() - 1 ||
12323  (reference_token[pos + 1] != '0' &&
12324  reference_token[pos + 1] != '1')))
12325  {
12326  JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
12327  }
12328  }
12329 
12330  // finally, store the reference token
12331  unescape(reference_token);
12332  result.push_back(reference_token);
12333  }
12334 
12335  return result;
12336  }
12337 
12338  /*!
12339  @brief replace all occurrences of a substring by another string
12340 
12341  @param[in,out] s the string to manipulate; changed so that all
12342  occurrences of @a f are replaced with @a t
12343  @param[in] f the substring to replace with @a t
12344  @param[in] t the string to replace @a f
12345 
12346  @pre The search string @a f must not be empty. **This precondition is
12347  enforced with an assertion.**
12348 
12349  @since version 2.0.0
12350  */
12351  static void replace_substring(std::string& s, const std::string& f,
12352  const std::string& t)
12353  {
12354  JSON_ASSERT(!f.empty());
12355  for (auto pos = s.find(f); // find first occurrence of f
12356  pos != std::string::npos; // make sure f was found
12357  s.replace(pos, f.size(), t), // replace with t, and
12358  pos = s.find(f, pos + t.size())) // find next occurrence of f
12359  {}
12360  }
12361 
12362  /// escape "~" to "~0" and "/" to "~1"
12363  static std::string escape(std::string s)
12364  {
12365  replace_substring(s, "~", "~0");
12366  replace_substring(s, "/", "~1");
12367  return s;
12368  }
12369 
12370  /// unescape "~1" to tilde and "~0" to slash (order is important!)
12371  static void unescape(std::string& s)
12372  {
12373  replace_substring(s, "~1", "/");
12374  replace_substring(s, "~0", "~");
12375  }
12376 
12377  /*!
12378  @param[in] reference_string the reference string to the current value
12379  @param[in] value the value to consider
12380  @param[in,out] result the result object to insert values to
12381 
12382  @note Empty objects or arrays are flattened to `null`.
12383  */
12384  static void flatten(const std::string& reference_string,
12385  const BasicJsonType& value,
12386  BasicJsonType& result)
12387  {
12388  switch (value.type())
12389  {
12391  {
12392  if (value.m_value.array->empty())
12393  {
12394  // flatten empty array as null
12395  result[reference_string] = nullptr;
12396  }
12397  else
12398  {
12399  // iterate array and use index as reference string
12400  for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
12401  {
12402  flatten(reference_string + "/" + std::to_string(i),
12403  value.m_value.array->operator[](i), result);
12404  }
12405  }
12406  break;
12407  }
12408 
12410  {
12411  if (value.m_value.object->empty())
12412  {
12413  // flatten empty object as null
12414  result[reference_string] = nullptr;
12415  }
12416  else
12417  {
12418  // iterate object and use keys as reference string
12419  for (const auto& element : *value.m_value.object)
12420  {
12421  flatten(reference_string + "/" + escape(element.first), element.second, result);
12422  }
12423  }
12424  break;
12425  }
12426 
12427  default:
12428  {
12429  // add primitive value with its reference string
12430  result[reference_string] = value;
12431  break;
12432  }
12433  }
12434  }
12435 
12436  /*!
12437  @param[in] value flattened JSON
12438 
12439  @return unflattened JSON
12440 
12441  @throw parse_error.109 if array index is not a number
12442  @throw type_error.314 if value is not an object
12443  @throw type_error.315 if object values are not primitive
12444  @throw type_error.313 if value cannot be unflattened
12445  */
12446  static BasicJsonType
12447  unflatten(const BasicJsonType& value)
12448  {
12449  if (JSON_HEDLEY_UNLIKELY(!value.is_object()))
12450  {
12451  JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
12452  }
12453 
12454  BasicJsonType result;
12455 
12456  // iterate the JSON object values
12457  for (const auto& element : *value.m_value.object)
12458  {
12459  if (JSON_HEDLEY_UNLIKELY(!element.second.is_primitive()))
12460  {
12461  JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
12462  }
12463 
12464  // assign value to reference pointed to by JSON pointer; Note that if
12465  // the JSON pointer is "" (i.e., points to the whole value), function
12466  // get_and_create returns a reference to result itself. An assignment
12467  // will then create a primitive value.
12468  json_pointer(element.first).get_and_create(result) = element.second;
12469  }
12470 
12471  return result;
12472  }
12473 
12474  /*!
12475  @brief compares two JSON pointers for equality
12476 
12477  @param[in] lhs JSON pointer to compare
12478  @param[in] rhs JSON pointer to compare
12479  @return whether @a lhs is equal to @a rhs
12480 
12481  @complexity Linear in the length of the JSON pointer
12482 
12483  @exceptionsafety No-throw guarantee: this function never throws exceptions.
12484  */
12485  friend bool operator==(json_pointer const& lhs,
12486  json_pointer const& rhs) noexcept
12487  {
12488  return lhs.reference_tokens == rhs.reference_tokens;
12489  }
12490 
12491  /*!
12492  @brief compares two JSON pointers for inequality
12493 
12494  @param[in] lhs JSON pointer to compare
12495  @param[in] rhs JSON pointer to compare
12496  @return whether @a lhs is not equal @a rhs
12497 
12498  @complexity Linear in the length of the JSON pointer
12499 
12500  @exceptionsafety No-throw guarantee: this function never throws exceptions.
12501  */
12502  friend bool operator!=(json_pointer const& lhs,
12503  json_pointer const& rhs) noexcept
12504  {
12505  return !(lhs == rhs);
12506  }
12507 
12508  /// the reference tokens
12509  std::vector<std::string> reference_tokens;
12510 };
12511 } // namespace nlohmann
12512 
12513 // #include <nlohmann/detail/json_ref.hpp>
12514 
12515 
12516 #include <initializer_list>
12517 #include <utility>
12518 
12519 // #include <nlohmann/detail/meta/type_traits.hpp>
12520 
12521 
12522 namespace nlohmann
12523 {
12524 namespace detail
12525 {
12526 template<typename BasicJsonType>
12528 {
12529  public:
12530  using value_type = BasicJsonType;
12531 
12532  json_ref(value_type&& value)
12533  : owned_value(std::move(value))
12534  , value_ref(&owned_value)
12535  , is_rvalue(true)
12536  {}
12537 
12538  json_ref(const value_type& value)
12539  : value_ref(const_cast<value_type*>(&value))
12540  , is_rvalue(false)
12541  {}
12542 
12543  json_ref(std::initializer_list<json_ref> init)
12544  : owned_value(init)
12545  , value_ref(&owned_value)
12546  , is_rvalue(true)
12547  {}
12548 
12549  template <
12550  class... Args,
12551  enable_if_t<std::is_constructible<value_type, Args...>::value, int> = 0 >
12552  json_ref(Args && ... args)
12553  : owned_value(std::forward<Args>(args)...)
12554  , value_ref(&owned_value)
12555  , is_rvalue(true)
12556  {}
12557 
12558  // class should be movable only
12559  json_ref(json_ref&&) = default;
12560  json_ref(const json_ref&) = delete;
12561  json_ref& operator=(const json_ref&) = delete;
12562  json_ref& operator=(json_ref&&) = delete;
12563  ~json_ref() = default;
12564 
12565  value_type moved_or_copied() const
12566  {
12567  if (is_rvalue)
12568  {
12569  return std::move(*value_ref);
12570  }
12571  return *value_ref;
12572  }
12573 
12574  value_type const& operator*() const
12575  {
12576  return *static_cast<value_type const*>(value_ref);
12577  }
12578 
12579  value_type const* operator->() const
12580  {
12581  return static_cast<value_type const*>(value_ref);
12582  }
12583 
12584  private:
12585  mutable value_type owned_value = nullptr;
12586  value_type* value_ref = nullptr;
12587  const bool is_rvalue = true;
12588 };
12589 } // namespace detail
12590 } // namespace nlohmann
12591 
12592 // #include <nlohmann/detail/macro_scope.hpp>
12593 
12594 // #include <nlohmann/detail/meta/cpp_future.hpp>
12595 
12596 // #include <nlohmann/detail/meta/type_traits.hpp>
12597 
12598 // #include <nlohmann/detail/output/binary_writer.hpp>
12599 
12600 
12601 #include <algorithm> // reverse
12602 #include <array> // array
12603 #include <cstdint> // uint8_t, uint16_t, uint32_t, uint64_t
12604 #include <cstring> // memcpy
12605 #include <limits> // numeric_limits
12606 #include <string> // string
12607 #include <cmath> // isnan, isinf
12608 
12609 // #include <nlohmann/detail/input/binary_reader.hpp>
12610 
12611 // #include <nlohmann/detail/macro_scope.hpp>
12612 
12613 // #include <nlohmann/detail/output/output_adapters.hpp>
12614 
12615 
12616 #include <algorithm> // copy
12617 #include <cstddef> // size_t
12618 #include <ios> // streamsize
12619 #include <iterator> // back_inserter
12620 #include <memory> // shared_ptr, make_shared
12621 #include <ostream> // basic_ostream
12622 #include <string> // basic_string
12623 #include <vector> // vector
12624 // #include <nlohmann/detail/macro_scope.hpp>
12625 
12626 
12627 namespace nlohmann
12628 {
12629 namespace detail
12630 {
12631 /// abstract output adapter interface
12632 template<typename CharType> struct output_adapter_protocol
12633 {
12634  virtual void write_character(CharType c) = 0;
12635  virtual void write_characters(const CharType* s, std::size_t length) = 0;
12636  virtual ~output_adapter_protocol() = default;
12637 };
12638 
12639 /// a type to simplify interfaces
12640 template<typename CharType>
12641 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;
12642 
12643 /// output adapter for byte vectors
12644 template<typename CharType>
12646 {
12647  public:
12648  explicit output_vector_adapter(std::vector<CharType>& vec) noexcept
12649  : v(vec)
12650  {}
12651 
12652  void write_character(CharType c) override
12653  {
12654  v.push_back(c);
12655  }
12656 
12657  JSON_HEDLEY_NON_NULL(2)
12658  void write_characters(const CharType* s, std::size_t length) override
12659  {
12660  std::copy(s, s + length, std::back_inserter(v));
12661  }
12662 
12663  private:
12664  std::vector<CharType>& v;
12665 };
12666 
12667 /// output adapter for output streams
12668 template<typename CharType>
12670 {
12671  public:
12672  explicit output_stream_adapter(std::basic_ostream<CharType>& s) noexcept
12673  : stream(s)
12674  {}
12675 
12676  void write_character(CharType c) override
12677  {
12678  stream.put(c);
12679  }
12680 
12681  JSON_HEDLEY_NON_NULL(2)
12682  void write_characters(const CharType* s, std::size_t length) override
12683  {
12684  stream.write(s, static_cast<std::streamsize>(length));
12685  }
12686 
12687  private:
12688  std::basic_ostream<CharType>& stream;
12689 };
12690 
12691 /// output adapter for basic_string
12692 template<typename CharType, typename StringType = std::basic_string<CharType>>
12694 {
12695  public:
12696  explicit output_string_adapter(StringType& s) noexcept
12697  : str(s)
12698  {}
12699 
12700  void write_character(CharType c) override
12701  {
12702  str.push_back(c);
12703  }
12704 
12705  JSON_HEDLEY_NON_NULL(2)
12706  void write_characters(const CharType* s, std::size_t length) override
12707  {
12708  str.append(s, length);
12709  }
12710 
12711  private:
12712  StringType& str;
12713 };
12714 
12715 template<typename CharType, typename StringType = std::basic_string<CharType>>
12717 {
12718  public:
12719  output_adapter(std::vector<CharType>& vec)
12720  : oa(std::make_shared<output_vector_adapter<CharType>>(vec)) {}
12721 
12722  output_adapter(std::basic_ostream<CharType>& s)
12723  : oa(std::make_shared<output_stream_adapter<CharType>>(s)) {}
12724 
12725  output_adapter(StringType& s)
12726  : oa(std::make_shared<output_string_adapter<CharType, StringType>>(s)) {}
12727 
12728  operator output_adapter_t<CharType>()
12729  {
12730  return oa;
12731  }
12732 
12733  private:
12734  output_adapter_t<CharType> oa = nullptr;
12735 };
12736 } // namespace detail
12737 } // namespace nlohmann
12738 
12739 
12740 namespace nlohmann
12741 {
12742 namespace detail
12743 {
12744 ///////////////////
12745 // binary writer //
12746 ///////////////////
12747 
12748 /*!
12749 @brief serialization to CBOR and MessagePack values
12750 */
12751 template<typename BasicJsonType, typename CharType>
12753 {
12754  using string_t = typename BasicJsonType::string_t;
12755  using binary_t = typename BasicJsonType::binary_t;
12756  using number_float_t = typename BasicJsonType::number_float_t;
12757 
12758  public:
12759  /*!
12760  @brief create a binary writer
12761 
12762  @param[in] adapter output adapter to write to
12763  */
12764  explicit binary_writer(output_adapter_t<CharType> adapter) : oa(adapter)
12765  {
12766  JSON_ASSERT(oa);
12767  }
12768 
12769  /*!
12770  @param[in] j JSON value to serialize
12771  @pre j.type() == value_t::object
12772  */
12773  void write_bson(const BasicJsonType& j)
12774  {
12775  switch (j.type())
12776  {
12777  case value_t::object:
12778  {
12779  write_bson_object(*j.m_value.object);
12780  break;
12781  }
12782 
12783  default:
12784  {
12785  JSON_THROW(type_error::create(317, "to serialize to BSON, top-level type must be object, but is " + std::string(j.type_name())));
12786  }
12787  }
12788  }
12789 
12790  /*!
12791  @param[in] j JSON value to serialize
12792  */
12793  void write_cbor(const BasicJsonType& j)
12794  {
12795  switch (j.type())
12796  {
12797  case value_t::null:
12798  {
12799  oa->write_character(to_char_type(0xF6));
12800  break;
12801  }
12802 
12803  case value_t::boolean:
12804  {
12805  oa->write_character(j.m_value.boolean
12806  ? to_char_type(0xF5)
12807  : to_char_type(0xF4));
12808  break;
12809  }
12810 
12812  {
12813  if (j.m_value.number_integer >= 0)
12814  {
12815  // CBOR does not differentiate between positive signed
12816  // integers and unsigned integers. Therefore, we used the
12817  // code from the value_t::number_unsigned case here.
12818  if (j.m_value.number_integer <= 0x17)
12819  {
12820  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
12821  }
12822  else if (j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
12823  {
12824  oa->write_character(to_char_type(0x18));
12825  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
12826  }
12827  else if (j.m_value.number_integer <= (std::numeric_limits<std::uint16_t>::max)())
12828  {
12829  oa->write_character(to_char_type(0x19));
12830  write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
12831  }
12832  else if (j.m_value.number_integer <= (std::numeric_limits<std::uint32_t>::max)())
12833  {
12834  oa->write_character(to_char_type(0x1A));
12835  write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
12836  }
12837  else
12838  {
12839  oa->write_character(to_char_type(0x1B));
12840  write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
12841  }
12842  }
12843  else
12844  {
12845  // The conversions below encode the sign in the first
12846  // byte, and the value is converted to a positive number.
12847  const auto positive_number = -1 - j.m_value.number_integer;
12848  if (j.m_value.number_integer >= -24)
12849  {
12850  write_number(static_cast<std::uint8_t>(0x20 + positive_number));
12851  }
12852  else if (positive_number <= (std::numeric_limits<std::uint8_t>::max)())
12853  {
12854  oa->write_character(to_char_type(0x38));
12855  write_number(static_cast<std::uint8_t>(positive_number));
12856  }
12857  else if (positive_number <= (std::numeric_limits<std::uint16_t>::max)())
12858  {
12859  oa->write_character(to_char_type(0x39));
12860  write_number(static_cast<std::uint16_t>(positive_number));
12861  }
12862  else if (positive_number <= (std::numeric_limits<std::uint32_t>::max)())
12863  {
12864  oa->write_character(to_char_type(0x3A));
12865  write_number(static_cast<std::uint32_t>(positive_number));
12866  }
12867  else
12868  {
12869  oa->write_character(to_char_type(0x3B));
12870  write_number(static_cast<std::uint64_t>(positive_number));
12871  }
12872  }
12873  break;
12874  }
12875 
12877  {
12878  if (j.m_value.number_unsigned <= 0x17)
12879  {
12880  write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
12881  }
12882  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
12883  {
12884  oa->write_character(to_char_type(0x18));
12885  write_number(static_cast<std::uint8_t>(j.m_value.number_unsigned));
12886  }
12887  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
12888  {
12889  oa->write_character(to_char_type(0x19));
12890  write_number(static_cast<std::uint16_t>(j.m_value.number_unsigned));
12891  }
12892  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
12893  {
12894  oa->write_character(to_char_type(0x1A));
12895  write_number(static_cast<std::uint32_t>(j.m_value.number_unsigned));
12896  }
12897  else
12898  {
12899  oa->write_character(to_char_type(0x1B));
12900  write_number(static_cast<std::uint64_t>(j.m_value.number_unsigned));
12901  }
12902  break;
12903  }
12904 
12905  case value_t::number_float:
12906  {
12907  if (std::isnan(j.m_value.number_float))
12908  {
12909  // NaN is 0xf97e00 in CBOR
12910  oa->write_character(to_char_type(0xF9));
12911  oa->write_character(to_char_type(0x7E));
12912  oa->write_character(to_char_type(0x00));
12913  }
12914  else if (std::isinf(j.m_value.number_float))
12915  {
12916  // Infinity is 0xf97c00, -Infinity is 0xf9fc00
12917  oa->write_character(to_char_type(0xf9));
12918  oa->write_character(j.m_value.number_float > 0 ? to_char_type(0x7C) : to_char_type(0xFC));
12919  oa->write_character(to_char_type(0x00));
12920  }
12921  else
12922  {
12923  write_compact_float(j.m_value.number_float, detail::input_format_t::cbor);
12924  }
12925  break;
12926  }
12927 
12928  case value_t::string:
12929  {
12930  // step 1: write control byte and the string length
12931  const auto N = j.m_value.string->size();
12932  if (N <= 0x17)
12933  {
12934  write_number(static_cast<std::uint8_t>(0x60 + N));
12935  }
12936  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
12937  {
12938  oa->write_character(to_char_type(0x78));
12939  write_number(static_cast<std::uint8_t>(N));
12940  }
12941  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
12942  {
12943  oa->write_character(to_char_type(0x79));
12944  write_number(static_cast<std::uint16_t>(N));
12945  }
12946  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
12947  {
12948  oa->write_character(to_char_type(0x7A));
12949  write_number(static_cast<std::uint32_t>(N));
12950  }
12951  // LCOV_EXCL_START
12952  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
12953  {
12954  oa->write_character(to_char_type(0x7B));
12955  write_number(static_cast<std::uint64_t>(N));
12956  }
12957  // LCOV_EXCL_STOP
12958 
12959  // step 2: write the string
12960  oa->write_characters(
12961  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
12962  j.m_value.string->size());
12963  break;
12964  }
12965 
12966  case value_t::array:
12967  {
12968  // step 1: write control byte and the array size
12969  const auto N = j.m_value.array->size();
12970  if (N <= 0x17)
12971  {
12972  write_number(static_cast<std::uint8_t>(0x80 + N));
12973  }
12974  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
12975  {
12976  oa->write_character(to_char_type(0x98));
12977  write_number(static_cast<std::uint8_t>(N));
12978  }
12979  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
12980  {
12981  oa->write_character(to_char_type(0x99));
12982  write_number(static_cast<std::uint16_t>(N));
12983  }
12984  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
12985  {
12986  oa->write_character(to_char_type(0x9A));
12987  write_number(static_cast<std::uint32_t>(N));
12988  }
12989  // LCOV_EXCL_START
12990  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
12991  {
12992  oa->write_character(to_char_type(0x9B));
12993  write_number(static_cast<std::uint64_t>(N));
12994  }
12995  // LCOV_EXCL_STOP
12996 
12997  // step 2: write each element
12998  for (const auto& el : *j.m_value.array)
12999  {
13000  write_cbor(el);
13001  }
13002  break;
13003  }
13004 
13005  case value_t::binary:
13006  {
13007  if (j.m_value.binary->has_subtype())
13008  {
13009  write_number(static_cast<std::uint8_t>(0xd8));
13010  write_number(j.m_value.binary->subtype());
13011  }
13012 
13013  // step 1: write control byte and the binary array size
13014  const auto N = j.m_value.binary->size();
13015  if (N <= 0x17)
13016  {
13017  write_number(static_cast<std::uint8_t>(0x40 + N));
13018  }
13019  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13020  {
13021  oa->write_character(to_char_type(0x58));
13022  write_number(static_cast<std::uint8_t>(N));
13023  }
13024  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13025  {
13026  oa->write_character(to_char_type(0x59));
13027  write_number(static_cast<std::uint16_t>(N));
13028  }
13029  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13030  {
13031  oa->write_character(to_char_type(0x5A));
13032  write_number(static_cast<std::uint32_t>(N));
13033  }
13034  // LCOV_EXCL_START
13035  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13036  {
13037  oa->write_character(to_char_type(0x5B));
13038  write_number(static_cast<std::uint64_t>(N));
13039  }
13040  // LCOV_EXCL_STOP
13041 
13042  // step 2: write each element
13043  oa->write_characters(
13044  reinterpret_cast<const CharType*>(j.m_value.binary->data()),
13045  N);
13046 
13047  break;
13048  }
13049 
13050  case value_t::object:
13051  {
13052  // step 1: write control byte and the object size
13053  const auto N = j.m_value.object->size();
13054  if (N <= 0x17)
13055  {
13056  write_number(static_cast<std::uint8_t>(0xA0 + N));
13057  }
13058  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13059  {
13060  oa->write_character(to_char_type(0xB8));
13061  write_number(static_cast<std::uint8_t>(N));
13062  }
13063  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13064  {
13065  oa->write_character(to_char_type(0xB9));
13066  write_number(static_cast<std::uint16_t>(N));
13067  }
13068  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13069  {
13070  oa->write_character(to_char_type(0xBA));
13071  write_number(static_cast<std::uint32_t>(N));
13072  }
13073  // LCOV_EXCL_START
13074  else if (N <= (std::numeric_limits<std::uint64_t>::max)())
13075  {
13076  oa->write_character(to_char_type(0xBB));
13077  write_number(static_cast<std::uint64_t>(N));
13078  }
13079  // LCOV_EXCL_STOP
13080 
13081  // step 2: write each element
13082  for (const auto& el : *j.m_value.object)
13083  {
13084  write_cbor(el.first);
13085  write_cbor(el.second);
13086  }
13087  break;
13088  }
13089 
13090  default:
13091  break;
13092  }
13093  }
13094 
13095  /*!
13096  @param[in] j JSON value to serialize
13097  */
13098  void write_msgpack(const BasicJsonType& j)
13099  {
13100  switch (j.type())
13101  {
13102  case value_t::null: // nil
13103  {
13104  oa->write_character(to_char_type(0xC0));
13105  break;
13106  }
13107 
13108  case value_t::boolean: // true and false
13109  {
13110  oa->write_character(j.m_value.boolean
13111  ? to_char_type(0xC3)
13112  : to_char_type(0xC2));
13113  break;
13114  }
13115 
13117  {
13118  if (j.m_value.number_integer >= 0)
13119  {
13120  // MessagePack does not differentiate between positive
13121  // signed integers and unsigned integers. Therefore, we used
13122  // the code from the value_t::number_unsigned case here.
13123  if (j.m_value.number_unsigned < 128)
13124  {
13125  // positive fixnum
13126  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13127  }
13128  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13129  {
13130  // uint 8
13131  oa->write_character(to_char_type(0xCC));
13132  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13133  }
13134  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13135  {
13136  // uint 16
13137  oa->write_character(to_char_type(0xCD));
13138  write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
13139  }
13140  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13141  {
13142  // uint 32
13143  oa->write_character(to_char_type(0xCE));
13144  write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
13145  }
13146  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13147  {
13148  // uint 64
13149  oa->write_character(to_char_type(0xCF));
13150  write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
13151  }
13152  }
13153  else
13154  {
13155  if (j.m_value.number_integer >= -32)
13156  {
13157  // negative fixnum
13158  write_number(static_cast<std::int8_t>(j.m_value.number_integer));
13159  }
13160  else if (j.m_value.number_integer >= (std::numeric_limits<std::int8_t>::min)() &&
13161  j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
13162  {
13163  // int 8
13164  oa->write_character(to_char_type(0xD0));
13165  write_number(static_cast<std::int8_t>(j.m_value.number_integer));
13166  }
13167  else if (j.m_value.number_integer >= (std::numeric_limits<std::int16_t>::min)() &&
13168  j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
13169  {
13170  // int 16
13171  oa->write_character(to_char_type(0xD1));
13172  write_number(static_cast<std::int16_t>(j.m_value.number_integer));
13173  }
13174  else if (j.m_value.number_integer >= (std::numeric_limits<std::int32_t>::min)() &&
13175  j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
13176  {
13177  // int 32
13178  oa->write_character(to_char_type(0xD2));
13179  write_number(static_cast<std::int32_t>(j.m_value.number_integer));
13180  }
13181  else if (j.m_value.number_integer >= (std::numeric_limits<std::int64_t>::min)() &&
13182  j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
13183  {
13184  // int 64
13185  oa->write_character(to_char_type(0xD3));
13186  write_number(static_cast<std::int64_t>(j.m_value.number_integer));
13187  }
13188  }
13189  break;
13190  }
13191 
13193  {
13194  if (j.m_value.number_unsigned < 128)
13195  {
13196  // positive fixnum
13197  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13198  }
13199  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint8_t>::max)())
13200  {
13201  // uint 8
13202  oa->write_character(to_char_type(0xCC));
13203  write_number(static_cast<std::uint8_t>(j.m_value.number_integer));
13204  }
13205  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint16_t>::max)())
13206  {
13207  // uint 16
13208  oa->write_character(to_char_type(0xCD));
13209  write_number(static_cast<std::uint16_t>(j.m_value.number_integer));
13210  }
13211  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint32_t>::max)())
13212  {
13213  // uint 32
13214  oa->write_character(to_char_type(0xCE));
13215  write_number(static_cast<std::uint32_t>(j.m_value.number_integer));
13216  }
13217  else if (j.m_value.number_unsigned <= (std::numeric_limits<std::uint64_t>::max)())
13218  {
13219  // uint 64
13220  oa->write_character(to_char_type(0xCF));
13221  write_number(static_cast<std::uint64_t>(j.m_value.number_integer));
13222  }
13223  break;
13224  }
13225 
13226  case value_t::number_float:
13227  {
13228  write_compact_float(j.m_value.number_float, detail::input_format_t::msgpack);
13229  break;
13230  }
13231 
13232  case value_t::string:
13233  {
13234  // step 1: write control byte and the string length
13235  const auto N = j.m_value.string->size();
13236  if (N <= 31)
13237  {
13238  // fixstr
13239  write_number(static_cast<std::uint8_t>(0xA0 | N));
13240  }
13241  else if (N <= (std::numeric_limits<std::uint8_t>::max)())
13242  {
13243  // str 8
13244  oa->write_character(to_char_type(0xD9));
13245  write_number(static_cast<std::uint8_t>(N));
13246  }
13247  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13248  {
13249  // str 16
13250  oa->write_character(to_char_type(0xDA));
13251  write_number(static_cast<std::uint16_t>(N));
13252  }
13253  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13254  {
13255  // str 32
13256  oa->write_character(to_char_type(0xDB));
13257  write_number(static_cast<std::uint32_t>(N));
13258  }
13259 
13260  // step 2: write the string
13261  oa->write_characters(
13262  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
13263  j.m_value.string->size());
13264  break;
13265  }
13266 
13267  case value_t::array:
13268  {
13269  // step 1: write control byte and the array size
13270  const auto N = j.m_value.array->size();
13271  if (N <= 15)
13272  {
13273  // fixarray
13274  write_number(static_cast<std::uint8_t>(0x90 | N));
13275  }
13276  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13277  {
13278  // array 16
13279  oa->write_character(to_char_type(0xDC));
13280  write_number(static_cast<std::uint16_t>(N));
13281  }
13282  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13283  {
13284  // array 32
13285  oa->write_character(to_char_type(0xDD));
13286  write_number(static_cast<std::uint32_t>(N));
13287  }
13288 
13289  // step 2: write each element
13290  for (const auto& el : *j.m_value.array)
13291  {
13292  write_msgpack(el);
13293  }
13294  break;
13295  }
13296 
13297  case value_t::binary:
13298  {
13299  // step 0: determine if the binary type has a set subtype to
13300  // determine whether or not to use the ext or fixext types
13301  const bool use_ext = j.m_value.binary->has_subtype();
13302 
13303  // step 1: write control byte and the byte string length
13304  const auto N = j.m_value.binary->size();
13305  if (N <= (std::numeric_limits<std::uint8_t>::max)())
13306  {
13307  std::uint8_t output_type{};
13308  bool fixed = true;
13309  if (use_ext)
13310  {
13311  switch (N)
13312  {
13313  case 1:
13314  output_type = 0xD4; // fixext 1
13315  break;
13316  case 2:
13317  output_type = 0xD5; // fixext 2
13318  break;
13319  case 4:
13320  output_type = 0xD6; // fixext 4
13321  break;
13322  case 8:
13323  output_type = 0xD7; // fixext 8
13324  break;
13325  case 16:
13326  output_type = 0xD8; // fixext 16
13327  break;
13328  default:
13329  output_type = 0xC7; // ext 8
13330  fixed = false;
13331  break;
13332  }
13333 
13334  }
13335  else
13336  {
13337  output_type = 0xC4; // bin 8
13338  fixed = false;
13339  }
13340 
13341  oa->write_character(to_char_type(output_type));
13342  if (!fixed)
13343  {
13344  write_number(static_cast<std::uint8_t>(N));
13345  }
13346  }
13347  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13348  {
13349  std::uint8_t output_type = use_ext
13350  ? 0xC8 // ext 16
13351  : 0xC5; // bin 16
13352 
13353  oa->write_character(to_char_type(output_type));
13354  write_number(static_cast<std::uint16_t>(N));
13355  }
13356  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13357  {
13358  std::uint8_t output_type = use_ext
13359  ? 0xC9 // ext 32
13360  : 0xC6; // bin 32
13361 
13362  oa->write_character(to_char_type(output_type));
13363  write_number(static_cast<std::uint32_t>(N));
13364  }
13365 
13366  // step 1.5: if this is an ext type, write the subtype
13367  if (use_ext)
13368  {
13369  write_number(static_cast<std::int8_t>(j.m_value.binary->subtype()));
13370  }
13371 
13372  // step 2: write the byte string
13373  oa->write_characters(
13374  reinterpret_cast<const CharType*>(j.m_value.binary->data()),
13375  N);
13376 
13377  break;
13378  }
13379 
13380  case value_t::object:
13381  {
13382  // step 1: write control byte and the object size
13383  const auto N = j.m_value.object->size();
13384  if (N <= 15)
13385  {
13386  // fixmap
13387  write_number(static_cast<std::uint8_t>(0x80 | (N & 0xF)));
13388  }
13389  else if (N <= (std::numeric_limits<std::uint16_t>::max)())
13390  {
13391  // map 16
13392  oa->write_character(to_char_type(0xDE));
13393  write_number(static_cast<std::uint16_t>(N));
13394  }
13395  else if (N <= (std::numeric_limits<std::uint32_t>::max)())
13396  {
13397  // map 32
13398  oa->write_character(to_char_type(0xDF));
13399  write_number(static_cast<std::uint32_t>(N));
13400  }
13401 
13402  // step 2: write each element
13403  for (const auto& el : *j.m_value.object)
13404  {
13405  write_msgpack(el.first);
13406  write_msgpack(el.second);
13407  }
13408  break;
13409  }
13410 
13411  default:
13412  break;
13413  }
13414  }
13415 
13416  /*!
13417  @param[in] j JSON value to serialize
13418  @param[in] use_count whether to use '#' prefixes (optimized format)
13419  @param[in] use_type whether to use '$' prefixes (optimized format)
13420  @param[in] add_prefix whether prefixes need to be used for this value
13421  */
13422  void write_ubjson(const BasicJsonType& j, const bool use_count,
13423  const bool use_type, const bool add_prefix = true)
13424  {
13425  switch (j.type())
13426  {
13427  case value_t::null:
13428  {
13429  if (add_prefix)
13430  {
13431  oa->write_character(to_char_type('Z'));
13432  }
13433  break;
13434  }
13435 
13436  case value_t::boolean:
13437  {
13438  if (add_prefix)
13439  {
13440  oa->write_character(j.m_value.boolean
13441  ? to_char_type('T')
13442  : to_char_type('F'));
13443  }
13444  break;
13445  }
13446 
13448  {
13449  write_number_with_ubjson_prefix(j.m_value.number_integer, add_prefix);
13450  break;
13451  }
13452 
13454  {
13455  write_number_with_ubjson_prefix(j.m_value.number_unsigned, add_prefix);
13456  break;
13457  }
13458 
13459  case value_t::number_float:
13460  {
13461  write_number_with_ubjson_prefix(j.m_value.number_float, add_prefix);
13462  break;
13463  }
13464 
13465  case value_t::string:
13466  {
13467  if (add_prefix)
13468  {
13469  oa->write_character(to_char_type('S'));
13470  }
13471  write_number_with_ubjson_prefix(j.m_value.string->size(), true);
13472  oa->write_characters(
13473  reinterpret_cast<const CharType*>(j.m_value.string->c_str()),
13474  j.m_value.string->size());
13475  break;
13476  }
13477 
13478  case value_t::array:
13479  {
13480  if (add_prefix)
13481  {
13482  oa->write_character(to_char_type('['));
13483  }
13484 
13485  bool prefix_required = true;
13486  if (use_type && !j.m_value.array->empty())
13487  {
13488  JSON_ASSERT(use_count);
13489  const CharType first_prefix = ubjson_prefix(j.front());
13490  const bool same_prefix = std::all_of(j.begin() + 1, j.end(),
13491  [this, first_prefix](const BasicJsonType & v)
13492  {
13493  return ubjson_prefix(v) == first_prefix;
13494  });
13495 
13496  if (same_prefix)
13497  {
13498  prefix_required = false;
13499  oa->write_character(to_char_type('$'));
13500  oa->write_character(first_prefix);
13501  }
13502  }
13503 
13504  if (use_count)
13505  {
13506  oa->write_character(to_char_type('#'));
13507  write_number_with_ubjson_prefix(j.m_value.array->size(), true);
13508  }
13509 
13510  for (const auto& el : *j.m_value.array)
13511  {
13512  write_ubjson(el, use_count, use_type, prefix_required);
13513  }
13514 
13515  if (!use_count)
13516  {
13517  oa->write_character(to_char_type(']'));
13518  }
13519 
13520  break;
13521  }
13522 
13523  case value_t::binary:
13524  {
13525  if (add_prefix)
13526  {
13527  oa->write_character(to_char_type('['));
13528  }
13529 
13530  if (use_type && !j.m_value.binary->empty())
13531  {
13532  JSON_ASSERT(use_count);
13533  oa->write_character(to_char_type('$'));
13534  oa->write_character('U');
13535  }
13536 
13537  if (use_count)
13538  {
13539  oa->write_character(to_char_type('#'));
13540  write_number_with_ubjson_prefix(j.m_value.binary->size(), true);
13541  }
13542 
13543  if (use_type)
13544  {
13545  oa->write_characters(
13546  reinterpret_cast<const CharType*>(j.m_value.binary->data()),
13547  j.m_value.binary->size());
13548  }
13549  else
13550  {
13551  for (size_t i = 0; i < j.m_value.binary->size(); ++i)
13552  {
13553  oa->write_character(to_char_type('U'));
13554  oa->write_character(j.m_value.binary->data()[i]);
13555  }
13556  }
13557 
13558  if (!use_count)
13559  {
13560  oa->write_character(to_char_type(']'));
13561  }
13562 
13563  break;
13564  }
13565 
13566  case value_t::object:
13567  {
13568  if (add_prefix)
13569  {
13570  oa->write_character(to_char_type('{'));
13571  }
13572 
13573  bool prefix_required = true;
13574  if (use_type && !j.m_value.object->empty())
13575  {
13576  JSON_ASSERT(use_count);
13577  const CharType first_prefix = ubjson_prefix(j.front());
13578  const bool same_prefix = std::all_of(j.begin(), j.end(),
13579  [this, first_prefix](const BasicJsonType & v)
13580  {
13581  return ubjson_prefix(v) == first_prefix;
13582  });
13583 
13584  if (same_prefix)
13585  {
13586  prefix_required = false;
13587  oa->write_character(to_char_type('$'));
13588  oa->write_character(first_prefix);
13589  }
13590  }
13591 
13592  if (use_count)
13593  {
13594  oa->write_character(to_char_type('#'));
13595  write_number_with_ubjson_prefix(j.m_value.object->size(), true);
13596  }
13597 
13598  for (const auto& el : *j.m_value.object)
13599  {
13600  write_number_with_ubjson_prefix(el.first.size(), true);
13601  oa->write_characters(
13602  reinterpret_cast<const CharType*>(el.first.c_str()),
13603  el.first.size());
13604  write_ubjson(el.second, use_count, use_type, prefix_required);
13605  }
13606 
13607  if (!use_count)
13608  {
13609  oa->write_character(to_char_type('}'));
13610  }
13611 
13612  break;
13613  }
13614 
13615  default:
13616  break;
13617  }
13618  }
13619 
13620  private:
13621  //////////
13622  // BSON //
13623  //////////
13624 
13625  /*!
13626  @return The size of a BSON document entry header, including the id marker
13627  and the entry name size (and its null-terminator).
13628  */
13629  static std::size_t calc_bson_entry_header_size(const string_t& name)
13630  {
13631  const auto it = name.find(static_cast<typename string_t::value_type>(0));
13632  if (JSON_HEDLEY_UNLIKELY(it != BasicJsonType::string_t::npos))
13633  {
13634  JSON_THROW(out_of_range::create(409,
13635  "BSON key cannot contain code point U+0000 (at byte " + std::to_string(it) + ")"));
13636  }
13637 
13638  return /*id*/ 1ul + name.size() + /*zero-terminator*/1u;
13639  }
13640 
13641  /*!
13642  @brief Writes the given @a element_type and @a name to the output adapter
13643  */
13644  void write_bson_entry_header(const string_t& name,
13645  const std::uint8_t element_type)
13646  {
13647  oa->write_character(to_char_type(element_type)); // boolean
13648  oa->write_characters(
13649  reinterpret_cast<const CharType*>(name.c_str()),
13650  name.size() + 1u);
13651  }
13652 
13653  /*!
13654  @brief Writes a BSON element with key @a name and boolean value @a value
13655  */
13656  void write_bson_boolean(const string_t& name,
13657  const bool value)
13658  {
13659  write_bson_entry_header(name, 0x08);
13660  oa->write_character(value ? to_char_type(0x01) : to_char_type(0x00));
13661  }
13662 
13663  /*!
13664  @brief Writes a BSON element with key @a name and double value @a value
13665  */
13666  void write_bson_double(const string_t& name,
13667  const double value)
13668  {
13669  write_bson_entry_header(name, 0x01);
13670  write_number<double, true>(value);
13671  }
13672 
13673  /*!
13674  @return The size of the BSON-encoded string in @a value
13675  */
13676  static std::size_t calc_bson_string_size(const string_t& value)
13677  {
13678  return sizeof(std::int32_t) + value.size() + 1ul;
13679  }
13680 
13681  /*!
13682  @brief Writes a BSON element with key @a name and string value @a value
13683  */
13684  void write_bson_string(const string_t& name,
13685  const string_t& value)
13686  {
13687  write_bson_entry_header(name, 0x02);
13688 
13689  write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size() + 1ul));
13690  oa->write_characters(
13691  reinterpret_cast<const CharType*>(value.c_str()),
13692  value.size() + 1);
13693  }
13694 
13695  /*!
13696  @brief Writes a BSON element with key @a name and null value
13697  */
13698  void write_bson_null(const string_t& name)
13699  {
13700  write_bson_entry_header(name, 0x0A);
13701  }
13702 
13703  /*!
13704  @return The size of the BSON-encoded integer @a value
13705  */
13706  static std::size_t calc_bson_integer_size(const std::int64_t value)
13707  {
13708  return (std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)()
13709  ? sizeof(std::int32_t)
13710  : sizeof(std::int64_t);
13711  }
13712 
13713  /*!
13714  @brief Writes a BSON element with key @a name and integer @a value
13715  */
13716  void write_bson_integer(const string_t& name,
13717  const std::int64_t value)
13718  {
13719  if ((std::numeric_limits<std::int32_t>::min)() <= value && value <= (std::numeric_limits<std::int32_t>::max)())
13720  {
13721  write_bson_entry_header(name, 0x10); // int32
13722  write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
13723  }
13724  else
13725  {
13726  write_bson_entry_header(name, 0x12); // int64
13727  write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
13728  }
13729  }
13730 
13731  /*!
13732  @return The size of the BSON-encoded unsigned integer in @a j
13733  */
13734  static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
13735  {
13736  return (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
13737  ? sizeof(std::int32_t)
13738  : sizeof(std::int64_t);
13739  }
13740 
13741  /*!
13742  @brief Writes a BSON element with key @a name and unsigned @a value
13743  */
13744  void write_bson_unsigned(const string_t& name,
13745  const std::uint64_t value)
13746  {
13747  if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
13748  {
13749  write_bson_entry_header(name, 0x10 /* int32 */);
13750  write_number<std::int32_t, true>(static_cast<std::int32_t>(value));
13751  }
13752  else if (value <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
13753  {
13754  write_bson_entry_header(name, 0x12 /* int64 */);
13755  write_number<std::int64_t, true>(static_cast<std::int64_t>(value));
13756  }
13757  else
13758  {
13759  JSON_THROW(out_of_range::create(407, "integer number " + std::to_string(value) + " cannot be represented by BSON as it does not fit int64"));
13760  }
13761  }
13762 
13763  /*!
13764  @brief Writes a BSON element with key @a name and object @a value
13765  */
13766  void write_bson_object_entry(const string_t& name,
13767  const typename BasicJsonType::object_t& value)
13768  {
13769  write_bson_entry_header(name, 0x03); // object
13771  }
13772 
13773  /*!
13774  @return The size of the BSON-encoded array @a value
13775  */
13776  static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t& value)
13777  {
13778  std::size_t array_index = 0ul;
13779 
13780  const std::size_t embedded_document_size = std::accumulate(std::begin(value), std::end(value), std::size_t(0), [&array_index](std::size_t result, const typename BasicJsonType::array_t::value_type & el)
13781  {
13782  return result + calc_bson_element_size(std::to_string(array_index++), el);
13783  });
13784 
13785  return sizeof(std::int32_t) + embedded_document_size + 1ul;
13786  }
13787 
13788  /*!
13789  @return The size of the BSON-encoded binary array @a value
13790  */
13791  static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t& value)
13792  {
13793  return sizeof(std::int32_t) + value.size() + 1ul;
13794  }
13795 
13796  /*!
13797  @brief Writes a BSON element with key @a name and array @a value
13798  */
13799  void write_bson_array(const string_t& name,
13800  const typename BasicJsonType::array_t& value)
13801  {
13802  write_bson_entry_header(name, 0x04); // array
13803  write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_array_size(value)));
13804 
13805  std::size_t array_index = 0ul;
13806 
13807  for (const auto& el : value)
13808  {
13809  write_bson_element(std::to_string(array_index++), el);
13810  }
13811 
13812  oa->write_character(to_char_type(0x00));
13813  }
13814 
13815  /*!
13816  @brief Writes a BSON element with key @a name and binary value @a value
13817  */
13818  void write_bson_binary(const string_t& name,
13819  const binary_t& value)
13820  {
13821  write_bson_entry_header(name, 0x05);
13822 
13823  write_number<std::int32_t, true>(static_cast<std::int32_t>(value.size()));
13824  write_number(value.has_subtype() ? value.subtype() : std::uint8_t(0x00));
13825 
13826  oa->write_characters(reinterpret_cast<const CharType*>(value.data()), value.size());
13827  }
13828 
13829  /*!
13830  @brief Calculates the size necessary to serialize the JSON value @a j with its @a name
13831  @return The calculated size for the BSON document entry for @a j with the given @a name.
13832  */
13833  static std::size_t calc_bson_element_size(const string_t& name,
13834  const BasicJsonType& j)
13835  {
13836  const auto header_size = calc_bson_entry_header_size(name);
13837  switch (j.type())
13838  {
13839  case value_t::object:
13840  return header_size + calc_bson_object_size(*j.m_value.object);
13841 
13842  case value_t::array:
13843  return header_size + calc_bson_array_size(*j.m_value.array);
13844 
13845  case value_t::binary:
13846  return header_size + calc_bson_binary_size(*j.m_value.binary);
13847 
13848  case value_t::boolean:
13849  return header_size + 1ul;
13850 
13851  case value_t::number_float:
13852  return header_size + 8ul;
13853 
13855  return header_size + calc_bson_integer_size(j.m_value.number_integer);
13856 
13858  return header_size + calc_bson_unsigned_size(j.m_value.number_unsigned);
13859 
13860  case value_t::string:
13861  return header_size + calc_bson_string_size(*j.m_value.string);
13862 
13863  case value_t::null:
13864  return header_size + 0ul;
13865 
13866  // LCOV_EXCL_START
13867  default:
13868  JSON_ASSERT(false);
13869  return 0ul;
13870  // LCOV_EXCL_STOP
13871  }
13872  }
13873 
13874  /*!
13875  @brief Serializes the JSON value @a j to BSON and associates it with the
13876  key @a name.
13877  @param name The name to associate with the JSON entity @a j within the
13878  current BSON document
13879  @return The size of the BSON entry
13880  */
13881  void write_bson_element(const string_t& name,
13882  const BasicJsonType& j)
13883  {
13884  switch (j.type())
13885  {
13886  case value_t::object:
13887  return write_bson_object_entry(name, *j.m_value.object);
13888 
13889  case value_t::array:
13890  return write_bson_array(name, *j.m_value.array);
13891 
13892  case value_t::binary:
13893  return write_bson_binary(name, *j.m_value.binary);
13894 
13895  case value_t::boolean:
13896  return write_bson_boolean(name, j.m_value.boolean);
13897 
13898  case value_t::number_float:
13899  return write_bson_double(name, j.m_value.number_float);
13900 
13902  return write_bson_integer(name, j.m_value.number_integer);
13903 
13905  return write_bson_unsigned(name, j.m_value.number_unsigned);
13906 
13907  case value_t::string:
13908  return write_bson_string(name, *j.m_value.string);
13909 
13910  case value_t::null:
13911  return write_bson_null(name);
13912 
13913  // LCOV_EXCL_START
13914  default:
13915  JSON_ASSERT(false);
13916  return;
13917  // LCOV_EXCL_STOP
13918  }
13919  }
13920 
13921  /*!
13922  @brief Calculates the size of the BSON serialization of the given
13923  JSON-object @a j.
13924  @param[in] j JSON value to serialize
13925  @pre j.type() == value_t::object
13926  */
13927  static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t& value)
13928  {
13929  std::size_t document_size = std::accumulate(value.begin(), value.end(), std::size_t(0),
13930  [](size_t result, const typename BasicJsonType::object_t::value_type & el)
13931  {
13932  return result += calc_bson_element_size(el.first, el.second);
13933  });
13934 
13935  return sizeof(std::int32_t) + document_size + 1ul;
13936  }
13937 
13938  /*!
13939  @param[in] j JSON value to serialize
13940  @pre j.type() == value_t::object
13941  */
13942  void write_bson_object(const typename BasicJsonType::object_t& value)
13943  {
13944  write_number<std::int32_t, true>(static_cast<std::int32_t>(calc_bson_object_size(value)));
13945 
13946  for (const auto& el : value)
13947  {
13948  write_bson_element(el.first, el.second);
13949  }
13950 
13951  oa->write_character(to_char_type(0x00));
13952  }
13953 
13954  //////////
13955  // CBOR //
13956  //////////
13957 
13958  static constexpr CharType get_cbor_float_prefix(float /*unused*/)
13959  {
13960  return to_char_type(0xFA); // Single-Precision Float
13961  }
13962 
13963  static constexpr CharType get_cbor_float_prefix(double /*unused*/)
13964  {
13965  return to_char_type(0xFB); // Double-Precision Float
13966  }
13967 
13968  /////////////
13969  // MsgPack //
13970  /////////////
13971 
13972  static constexpr CharType get_msgpack_float_prefix(float /*unused*/)
13973  {
13974  return to_char_type(0xCA); // float 32
13975  }
13976 
13977  static constexpr CharType get_msgpack_float_prefix(double /*unused*/)
13978  {
13979  return to_char_type(0xCB); // float 64
13980  }
13981 
13982  ////////////
13983  // UBJSON //
13984  ////////////
13985 
13986  // UBJSON: write number (floating point)
13987  template<typename NumberType, typename std::enable_if<
13988  std::is_floating_point<NumberType>::value, int>::type = 0>
13989  void write_number_with_ubjson_prefix(const NumberType n,
13990  const bool add_prefix)
13991  {
13992  if (add_prefix)
13993  {
13994  oa->write_character(get_ubjson_float_prefix(n));
13995  }
13996  write_number(n);
13997  }
13998 
13999  // UBJSON: write number (unsigned integer)
14000  template<typename NumberType, typename std::enable_if<
14001  std::is_unsigned<NumberType>::value, int>::type = 0>
14002  void write_number_with_ubjson_prefix(const NumberType n,
14003  const bool add_prefix)
14004  {
14005  if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
14006  {
14007  if (add_prefix)
14008  {
14009  oa->write_character(to_char_type('i')); // int8
14010  }
14011  write_number(static_cast<std::uint8_t>(n));
14012  }
14013  else if (n <= (std::numeric_limits<std::uint8_t>::max)())
14014  {
14015  if (add_prefix)
14016  {
14017  oa->write_character(to_char_type('U')); // uint8
14018  }
14019  write_number(static_cast<std::uint8_t>(n));
14020  }
14021  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
14022  {
14023  if (add_prefix)
14024  {
14025  oa->write_character(to_char_type('I')); // int16
14026  }
14027  write_number(static_cast<std::int16_t>(n));
14028  }
14029  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14030  {
14031  if (add_prefix)
14032  {
14033  oa->write_character(to_char_type('l')); // int32
14034  }
14035  write_number(static_cast<std::int32_t>(n));
14036  }
14037  else if (n <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
14038  {
14039  if (add_prefix)
14040  {
14041  oa->write_character(to_char_type('L')); // int64
14042  }
14043  write_number(static_cast<std::int64_t>(n));
14044  }
14045  else
14046  {
14047  if (add_prefix)
14048  {
14049  oa->write_character(to_char_type('H')); // high-precision number
14050  }
14051 
14052  const auto number = BasicJsonType(n).dump();
14053  write_number_with_ubjson_prefix(number.size(), true);
14054  for (std::size_t i = 0; i < number.size(); ++i)
14055  {
14056  oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
14057  }
14058  }
14059  }
14060 
14061  // UBJSON: write number (signed integer)
14062  template < typename NumberType, typename std::enable_if <
14063  std::is_signed<NumberType>::value&&
14064  !std::is_floating_point<NumberType>::value, int >::type = 0 >
14065  void write_number_with_ubjson_prefix(const NumberType n,
14066  const bool add_prefix)
14067  {
14068  if ((std::numeric_limits<std::int8_t>::min)() <= n && n <= (std::numeric_limits<std::int8_t>::max)())
14069  {
14070  if (add_prefix)
14071  {
14072  oa->write_character(to_char_type('i')); // int8
14073  }
14074  write_number(static_cast<std::int8_t>(n));
14075  }
14076  else if (static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::min)()) <= n && n <= static_cast<std::int64_t>((std::numeric_limits<std::uint8_t>::max)()))
14077  {
14078  if (add_prefix)
14079  {
14080  oa->write_character(to_char_type('U')); // uint8
14081  }
14082  write_number(static_cast<std::uint8_t>(n));
14083  }
14084  else if ((std::numeric_limits<std::int16_t>::min)() <= n && n <= (std::numeric_limits<std::int16_t>::max)())
14085  {
14086  if (add_prefix)
14087  {
14088  oa->write_character(to_char_type('I')); // int16
14089  }
14090  write_number(static_cast<std::int16_t>(n));
14091  }
14092  else if ((std::numeric_limits<std::int32_t>::min)() <= n && n <= (std::numeric_limits<std::int32_t>::max)())
14093  {
14094  if (add_prefix)
14095  {
14096  oa->write_character(to_char_type('l')); // int32
14097  }
14098  write_number(static_cast<std::int32_t>(n));
14099  }
14100  else if ((std::numeric_limits<std::int64_t>::min)() <= n && n <= (std::numeric_limits<std::int64_t>::max)())
14101  {
14102  if (add_prefix)
14103  {
14104  oa->write_character(to_char_type('L')); // int64
14105  }
14106  write_number(static_cast<std::int64_t>(n));
14107  }
14108  // LCOV_EXCL_START
14109  else
14110  {
14111  if (add_prefix)
14112  {
14113  oa->write_character(to_char_type('H')); // high-precision number
14114  }
14115 
14116  const auto number = BasicJsonType(n).dump();
14117  write_number_with_ubjson_prefix(number.size(), true);
14118  for (std::size_t i = 0; i < number.size(); ++i)
14119  {
14120  oa->write_character(to_char_type(static_cast<std::uint8_t>(number[i])));
14121  }
14122  }
14123  // LCOV_EXCL_STOP
14124  }
14125 
14126  /*!
14127  @brief determine the type prefix of container values
14128  */
14129  CharType ubjson_prefix(const BasicJsonType& j) const noexcept
14130  {
14131  switch (j.type())
14132  {
14133  case value_t::null:
14134  return 'Z';
14135 
14136  case value_t::boolean:
14137  return j.m_value.boolean ? 'T' : 'F';
14138 
14140  {
14141  if ((std::numeric_limits<std::int8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int8_t>::max)())
14142  {
14143  return 'i';
14144  }
14145  if ((std::numeric_limits<std::uint8_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::uint8_t>::max)())
14146  {
14147  return 'U';
14148  }
14149  if ((std::numeric_limits<std::int16_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int16_t>::max)())
14150  {
14151  return 'I';
14152  }
14153  if ((std::numeric_limits<std::int32_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int32_t>::max)())
14154  {
14155  return 'l';
14156  }
14157  if ((std::numeric_limits<std::int64_t>::min)() <= j.m_value.number_integer && j.m_value.number_integer <= (std::numeric_limits<std::int64_t>::max)())
14158  {
14159  return 'L';
14160  }
14161  // anything else is treated as high-precision number
14162  return 'H'; // LCOV_EXCL_LINE
14163  }
14164 
14166  {
14167  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int8_t>::max)()))
14168  {
14169  return 'i';
14170  }
14171  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::uint8_t>::max)()))
14172  {
14173  return 'U';
14174  }
14175  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int16_t>::max)()))
14176  {
14177  return 'I';
14178  }
14179  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int32_t>::max)()))
14180  {
14181  return 'l';
14182  }
14183  if (j.m_value.number_unsigned <= static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()))
14184  {
14185  return 'L';
14186  }
14187  // anything else is treated as high-precision number
14188  return 'H'; // LCOV_EXCL_LINE
14189  }
14190 
14191  case value_t::number_float:
14192  return get_ubjson_float_prefix(j.m_value.number_float);
14193 
14194  case value_t::string:
14195  return 'S';
14196 
14197  case value_t::array: // fallthrough
14198  case value_t::binary:
14199  return '[';
14200 
14201  case value_t::object:
14202  return '{';
14203 
14204  default: // discarded values
14205  return 'N';
14206  }
14207  }
14208 
14209  static constexpr CharType get_ubjson_float_prefix(float /*unused*/)
14210  {
14211  return 'd'; // float 32
14212  }
14213 
14214  static constexpr CharType get_ubjson_float_prefix(double /*unused*/)
14215  {
14216  return 'D'; // float 64
14217  }
14218 
14219  ///////////////////////
14220  // Utility functions //
14221  ///////////////////////
14222 
14223  /*
14224  @brief write a number to output input
14225  @param[in] n number of type @a NumberType
14226  @tparam NumberType the type of the number
14227  @tparam OutputIsLittleEndian Set to true if output data is
14228  required to be little endian
14229 
14230  @note This function needs to respect the system's endianess, because bytes
14231  in CBOR, MessagePack, and UBJSON are stored in network order (big
14232  endian) and therefore need reordering on little endian systems.
14233  */
14234  template<typename NumberType, bool OutputIsLittleEndian = false>
14235  void write_number(const NumberType n)
14236  {
14237  // step 1: write number to array of length NumberType
14238  std::array<CharType, sizeof(NumberType)> vec;
14239  std::memcpy(vec.data(), &n, sizeof(NumberType));
14240 
14241  // step 2: write array to output (with possible reordering)
14242  if (is_little_endian != OutputIsLittleEndian)
14243  {
14244  // reverse byte order prior to conversion if necessary
14245  std::reverse(vec.begin(), vec.end());
14246  }
14247 
14248  oa->write_characters(vec.data(), sizeof(NumberType));
14249  }
14250 
14251  void write_compact_float(const number_float_t n, detail::input_format_t format)
14252  {
14253  if (static_cast<double>(n) >= static_cast<double>(std::numeric_limits<float>::lowest()) &&
14254  static_cast<double>(n) <= static_cast<double>((std::numeric_limits<float>::max)()) &&
14255  static_cast<double>(static_cast<float>(n)) == static_cast<double>(n))
14256  {
14257  oa->write_character(format == detail::input_format_t::cbor
14258  ? get_cbor_float_prefix(static_cast<float>(n))
14259  : get_msgpack_float_prefix(static_cast<float>(n)));
14260  write_number(static_cast<float>(n));
14261  }
14262  else
14263  {
14264  oa->write_character(format == detail::input_format_t::cbor
14265  ? get_cbor_float_prefix(n)
14266  : get_msgpack_float_prefix(n));
14267  write_number(n);
14268  }
14269  }
14270 
14271  public:
14272  // The following to_char_type functions are implement the conversion
14273  // between uint8_t and CharType. In case CharType is not unsigned,
14274  // such a conversion is required to allow values greater than 128.
14275  // See <https://github.com/nlohmann/json/issues/1286> for a discussion.
14276  template < typename C = CharType,
14277  enable_if_t < std::is_signed<C>::value && std::is_signed<char>::value > * = nullptr >
14278  static constexpr CharType to_char_type(std::uint8_t x) noexcept
14279  {
14280  return *reinterpret_cast<char*>(&x);
14281  }
14282 
14283  template < typename C = CharType,
14284  enable_if_t < std::is_signed<C>::value && std::is_unsigned<char>::value > * = nullptr >
14285  static CharType to_char_type(std::uint8_t x) noexcept
14286  {
14287  static_assert(sizeof(std::uint8_t) == sizeof(CharType), "size of CharType must be equal to std::uint8_t");
14288  static_assert(std::is_trivial<CharType>::value, "CharType must be trivial");
14289  CharType result;
14290  std::memcpy(&result, &x, sizeof(x));
14291  return result;
14292  }
14293 
14294  template<typename C = CharType,
14295  enable_if_t<std::is_unsigned<C>::value>* = nullptr>
14296  static constexpr CharType to_char_type(std::uint8_t x) noexcept
14297  {
14298  return x;
14299  }
14300 
14301  template < typename InputCharType, typename C = CharType,
14302  enable_if_t <
14303  std::is_signed<C>::value &&
14304  std::is_signed<char>::value &&
14305  std::is_same<char, typename std::remove_cv<InputCharType>::type>::value
14306  > * = nullptr >
14307  static constexpr CharType to_char_type(InputCharType x) noexcept
14308  {
14309  return x;
14310  }
14311 
14312  private:
14313  /// whether we can assume little endianess
14315 
14316  /// the output
14318 };
14319 } // namespace detail
14320 } // namespace nlohmann
14321 
14322 // #include <nlohmann/detail/output/output_adapters.hpp>
14323 
14324 // #include <nlohmann/detail/output/serializer.hpp>
14325 
14326 
14327 #include <algorithm> // reverse, remove, fill, find, none_of
14328 #include <array> // array
14329 #include <clocale> // localeconv, lconv
14330 #include <cmath> // labs, isfinite, isnan, signbit
14331 #include <cstddef> // size_t, ptrdiff_t
14332 #include <cstdint> // uint8_t
14333 #include <cstdio> // snprintf
14334 #include <limits> // numeric_limits
14335 #include <string> // string, char_traits
14336 #include <type_traits> // is_same
14337 #include <utility> // move
14338 
14339 // #include <nlohmann/detail/conversions/to_chars.hpp>
14340 
14341 
14342 #include <array> // array
14343 #include <cmath> // signbit, isfinite
14344 #include <cstdint> // intN_t, uintN_t
14345 #include <cstring> // memcpy, memmove
14346 #include <limits> // numeric_limits
14347 #include <type_traits> // conditional
14348 
14349 // #include <nlohmann/detail/macro_scope.hpp>
14350 
14351 
14352 namespace nlohmann
14353 {
14354 namespace detail
14355 {
14356 
14357 /*!
14358 @brief implements the Grisu2 algorithm for binary to decimal floating-point
14359 conversion.
14360 
14361 This implementation is a slightly modified version of the reference
14362 implementation which may be obtained from
14363 http://florian.loitsch.com/publications (bench.tar.gz).
14364 
14365 The code is distributed under the MIT license, Copyright (c) 2009 Florian Loitsch.
14366 
14367 For a detailed description of the algorithm see:
14368 
14369 [1] Loitsch, "Printing Floating-Point Numbers Quickly and Accurately with
14370  Integers", Proceedings of the ACM SIGPLAN 2010 Conference on Programming
14371  Language Design and Implementation, PLDI 2010
14372 [2] Burger, Dybvig, "Printing Floating-Point Numbers Quickly and Accurately",
14373  Proceedings of the ACM SIGPLAN 1996 Conference on Programming Language
14374  Design and Implementation, PLDI 1996
14375 */
14376 namespace dtoa_impl
14377 {
14378 
14379 template<typename Target, typename Source>
14380 Target reinterpret_bits(const Source source)
14381 {
14382  static_assert(sizeof(Target) == sizeof(Source), "size mismatch");
14383 
14384  Target target;
14385  std::memcpy(&target, &source, sizeof(Source));
14386  return target;
14387 }
14388 
14389 struct diyfp // f * 2^e
14390 {
14391  static constexpr int kPrecision = 64; // = q
14392 
14393  std::uint64_t f = 0;
14394  int e = 0;
14395 
14396  constexpr diyfp(std::uint64_t f_, int e_) noexcept : f(f_), e(e_) {}
14397 
14398  /*!
14399  @brief returns x - y
14400  @pre x.e == y.e and x.f >= y.f
14401  */
14402  static diyfp sub(const diyfp& x, const diyfp& y) noexcept
14403  {
14404  JSON_ASSERT(x.e == y.e);
14405  JSON_ASSERT(x.f >= y.f);
14406 
14407  return {x.f - y.f, x.e};
14408  }
14409 
14410  /*!
14411  @brief returns x * y
14412  @note The result is rounded. (Only the upper q bits are returned.)
14413  */
14414  static diyfp mul(const diyfp& x, const diyfp& y) noexcept
14415  {
14416  static_assert(kPrecision == 64, "internal error");
14417 
14418  // Computes:
14419  // f = round((x.f * y.f) / 2^q)
14420  // e = x.e + y.e + q
14421 
14422  // Emulate the 64-bit * 64-bit multiplication:
14423  //
14424  // p = u * v
14425  // = (u_lo + 2^32 u_hi) (v_lo + 2^32 v_hi)
14426  // = (u_lo v_lo ) + 2^32 ((u_lo v_hi ) + (u_hi v_lo )) + 2^64 (u_hi v_hi )
14427  // = (p0 ) + 2^32 ((p1 ) + (p2 )) + 2^64 (p3 )
14428  // = (p0_lo + 2^32 p0_hi) + 2^32 ((p1_lo + 2^32 p1_hi) + (p2_lo + 2^32 p2_hi)) + 2^64 (p3 )
14429  // = (p0_lo ) + 2^32 (p0_hi + p1_lo + p2_lo ) + 2^64 (p1_hi + p2_hi + p3)
14430  // = (p0_lo ) + 2^32 (Q ) + 2^64 (H )
14431  // = (p0_lo ) + 2^32 (Q_lo + 2^32 Q_hi ) + 2^64 (H )
14432  //
14433  // (Since Q might be larger than 2^32 - 1)
14434  //
14435  // = (p0_lo + 2^32 Q_lo) + 2^64 (Q_hi + H)
14436  //
14437  // (Q_hi + H does not overflow a 64-bit int)
14438  //
14439  // = p_lo + 2^64 p_hi
14440 
14441  const std::uint64_t u_lo = x.f & 0xFFFFFFFFu;
14442  const std::uint64_t u_hi = x.f >> 32u;
14443  const std::uint64_t v_lo = y.f & 0xFFFFFFFFu;
14444  const std::uint64_t v_hi = y.f >> 32u;
14445 
14446  const std::uint64_t p0 = u_lo * v_lo;
14447  const std::uint64_t p1 = u_lo * v_hi;
14448  const std::uint64_t p2 = u_hi * v_lo;
14449  const std::uint64_t p3 = u_hi * v_hi;
14450 
14451  const std::uint64_t p0_hi = p0 >> 32u;
14452  const std::uint64_t p1_lo = p1 & 0xFFFFFFFFu;
14453  const std::uint64_t p1_hi = p1 >> 32u;
14454  const std::uint64_t p2_lo = p2 & 0xFFFFFFFFu;
14455  const std::uint64_t p2_hi = p2 >> 32u;
14456 
14457  std::uint64_t Q = p0_hi + p1_lo + p2_lo;
14458 
14459  // The full product might now be computed as
14460  //
14461  // p_hi = p3 + p2_hi + p1_hi + (Q >> 32)
14462  // p_lo = p0_lo + (Q << 32)
14463  //
14464  // But in this particular case here, the full p_lo is not required.
14465  // Effectively we only need to add the highest bit in p_lo to p_hi (and
14466  // Q_hi + 1 does not overflow).
14467 
14468  Q += std::uint64_t{1} << (64u - 32u - 1u); // round, ties up
14469 
14470  const std::uint64_t h = p3 + p2_hi + p1_hi + (Q >> 32u);
14471 
14472  return {h, x.e + y.e + 64};
14473  }
14474 
14475  /*!
14476  @brief normalize x such that the significand is >= 2^(q-1)
14477  @pre x.f != 0
14478  */
14479  static diyfp normalize(diyfp x) noexcept
14480  {
14481  JSON_ASSERT(x.f != 0);
14482 
14483  while ((x.f >> 63u) == 0)
14484  {
14485  x.f <<= 1u;
14486  x.e--;
14487  }
14488 
14489  return x;
14490  }
14491 
14492  /*!
14493  @brief normalize x such that the result has the exponent E
14494  @pre e >= x.e and the upper e - x.e bits of x.f must be zero.
14495  */
14496  static diyfp normalize_to(const diyfp& x, const int target_exponent) noexcept
14497  {
14498  const int delta = x.e - target_exponent;
14499 
14500  JSON_ASSERT(delta >= 0);
14501  JSON_ASSERT(((x.f << delta) >> delta) == x.f);
14502 
14503  return {x.f << delta, target_exponent};
14504  }
14505 };
14506 
14508 {
14509  diyfp w;
14510  diyfp minus;
14511  diyfp plus;
14512 };
14513 
14514 /*!
14515 Compute the (normalized) diyfp representing the input number 'value' and its
14516 boundaries.
14517 
14518 @pre value must be finite and positive
14519 */
14520 template<typename FloatType>
14522 {
14523  JSON_ASSERT(std::isfinite(value));
14524  JSON_ASSERT(value > 0);
14525 
14526  // Convert the IEEE representation into a diyfp.
14527  //
14528  // If v is denormal:
14529  // value = 0.F * 2^(1 - bias) = ( F) * 2^(1 - bias - (p-1))
14530  // If v is normalized:
14531  // value = 1.F * 2^(E - bias) = (2^(p-1) + F) * 2^(E - bias - (p-1))
14532 
14533  static_assert(std::numeric_limits<FloatType>::is_iec559,
14534  "internal error: dtoa_short requires an IEEE-754 floating-point implementation");
14535 
14536  constexpr int kPrecision = std::numeric_limits<FloatType>::digits; // = p (includes the hidden bit)
14537  constexpr int kBias = std::numeric_limits<FloatType>::max_exponent - 1 + (kPrecision - 1);
14538  constexpr int kMinExp = 1 - kBias;
14539  constexpr std::uint64_t kHiddenBit = std::uint64_t{1} << (kPrecision - 1); // = 2^(p-1)
14540 
14541  using bits_type = typename std::conditional<kPrecision == 24, std::uint32_t, std::uint64_t >::type;
14542 
14543  const std::uint64_t bits = reinterpret_bits<bits_type>(value);
14544  const std::uint64_t E = bits >> (kPrecision - 1);
14545  const std::uint64_t F = bits & (kHiddenBit - 1);
14546 
14547  const bool is_denormal = E == 0;
14548  const diyfp v = is_denormal
14549  ? diyfp(F, kMinExp)
14550  : diyfp(F + kHiddenBit, static_cast<int>(E) - kBias);
14551 
14552  // Compute the boundaries m- and m+ of the floating-point value
14553  // v = f * 2^e.
14554  //
14555  // Determine v- and v+, the floating-point predecessor and successor if v,
14556  // respectively.
14557  //
14558  // v- = v - 2^e if f != 2^(p-1) or e == e_min (A)
14559  // = v - 2^(e-1) if f == 2^(p-1) and e > e_min (B)
14560  //
14561  // v+ = v + 2^e
14562  //
14563  // Let m- = (v- + v) / 2 and m+ = (v + v+) / 2. All real numbers _strictly_
14564  // between m- and m+ round to v, regardless of how the input rounding
14565  // algorithm breaks ties.
14566  //
14567  // ---+-------------+-------------+-------------+-------------+--- (A)
14568  // v- m- v m+ v+
14569  //
14570  // -----------------+------+------+-------------+-------------+--- (B)
14571  // v- m- v m+ v+
14572 
14573  const bool lower_boundary_is_closer = F == 0 && E > 1;
14574  const diyfp m_plus = diyfp(2 * v.f + 1, v.e - 1);
14575  const diyfp m_minus = lower_boundary_is_closer
14576  ? diyfp(4 * v.f - 1, v.e - 2) // (B)
14577  : diyfp(2 * v.f - 1, v.e - 1); // (A)
14578 
14579  // Determine the normalized w+ = m+.
14580  const diyfp w_plus = diyfp::normalize(m_plus);
14581 
14582  // Determine w- = m- such that e_(w-) = e_(w+).
14583  const diyfp w_minus = diyfp::normalize_to(m_minus, w_plus.e);
14584 
14585  return {diyfp::normalize(v), w_minus, w_plus};
14586 }
14587 
14588 // Given normalized diyfp w, Grisu needs to find a (normalized) cached
14589 // power-of-ten c, such that the exponent of the product c * w = f * 2^e lies
14590 // within a certain range [alpha, gamma] (Definition 3.2 from [1])
14591 //
14592 // alpha <= e = e_c + e_w + q <= gamma
14593 //
14594 // or
14595 //
14596 // f_c * f_w * 2^alpha <= f_c 2^(e_c) * f_w 2^(e_w) * 2^q
14597 // <= f_c * f_w * 2^gamma
14598 //
14599 // Since c and w are normalized, i.e. 2^(q-1) <= f < 2^q, this implies
14600 //
14601 // 2^(q-1) * 2^(q-1) * 2^alpha <= c * w * 2^q < 2^q * 2^q * 2^gamma
14602 //
14603 // or
14604 //
14605 // 2^(q - 2 + alpha) <= c * w < 2^(q + gamma)
14606 //
14607 // The choice of (alpha,gamma) determines the size of the table and the form of
14608 // the digit generation procedure. Using (alpha,gamma)=(-60,-32) works out well
14609 // in practice:
14610 //
14611 // The idea is to cut the number c * w = f * 2^e into two parts, which can be
14612 // processed independently: An integral part p1, and a fractional part p2:
14613 //
14614 // f * 2^e = ( (f div 2^-e) * 2^-e + (f mod 2^-e) ) * 2^e
14615 // = (f div 2^-e) + (f mod 2^-e) * 2^e
14616 // = p1 + p2 * 2^e
14617 //
14618 // The conversion of p1 into decimal form requires a series of divisions and
14619 // modulos by (a power of) 10. These operations are faster for 32-bit than for
14620 // 64-bit integers, so p1 should ideally fit into a 32-bit integer. This can be
14621 // achieved by choosing
14622 //
14623 // -e >= 32 or e <= -32 := gamma
14624 //
14625 // In order to convert the fractional part
14626 //
14627 // p2 * 2^e = p2 / 2^-e = d[-1] / 10^1 + d[-2] / 10^2 + ...
14628 //
14629 // into decimal form, the fraction is repeatedly multiplied by 10 and the digits
14630 // d[-i] are extracted in order:
14631 //
14632 // (10 * p2) div 2^-e = d[-1]
14633 // (10 * p2) mod 2^-e = d[-2] / 10^1 + ...
14634 //
14635 // The multiplication by 10 must not overflow. It is sufficient to choose
14636 //
14637 // 10 * p2 < 16 * p2 = 2^4 * p2 <= 2^64.
14638 //
14639 // Since p2 = f mod 2^-e < 2^-e,
14640 //
14641 // -e <= 60 or e >= -60 := alpha
14642 
14643 constexpr int kAlpha = -60;
14644 constexpr int kGamma = -32;
14645 
14646 struct cached_power // c = f * 2^e ~= 10^k
14647 {
14648  std::uint64_t f;
14649  int e;
14650  int k;
14651 };
14652 
14653 /*!
14654 For a normalized diyfp w = f * 2^e, this function returns a (normalized) cached
14655 power-of-ten c = f_c * 2^e_c, such that the exponent of the product w * c
14656 satisfies (Definition 3.2 from [1])
14657 
14658  alpha <= e_c + e + q <= gamma.
14659 */
14661 {
14662  // Now
14663  //
14664  // alpha <= e_c + e + q <= gamma (1)
14665  // ==> f_c * 2^alpha <= c * 2^e * 2^q
14666  //
14667  // and since the c's are normalized, 2^(q-1) <= f_c,
14668  //
14669  // ==> 2^(q - 1 + alpha) <= c * 2^(e + q)
14670  // ==> 2^(alpha - e - 1) <= c
14671  //
14672  // If c were an exact power of ten, i.e. c = 10^k, one may determine k as
14673  //
14674  // k = ceil( log_10( 2^(alpha - e - 1) ) )
14675  // = ceil( (alpha - e - 1) * log_10(2) )
14676  //
14677  // From the paper:
14678  // "In theory the result of the procedure could be wrong since c is rounded,
14679  // and the computation itself is approximated [...]. In practice, however,
14680  // this simple function is sufficient."
14681  //
14682  // For IEEE double precision floating-point numbers converted into
14683  // normalized diyfp's w = f * 2^e, with q = 64,
14684  //
14685  // e >= -1022 (min IEEE exponent)
14686  // -52 (p - 1)
14687  // -52 (p - 1, possibly normalize denormal IEEE numbers)
14688  // -11 (normalize the diyfp)
14689  // = -1137
14690  //
14691  // and
14692  //
14693  // e <= +1023 (max IEEE exponent)
14694  // -52 (p - 1)
14695  // -11 (normalize the diyfp)
14696  // = 960
14697  //
14698  // This binary exponent range [-1137,960] results in a decimal exponent
14699  // range [-307,324]. One does not need to store a cached power for each
14700  // k in this range. For each such k it suffices to find a cached power
14701  // such that the exponent of the product lies in [alpha,gamma].
14702  // This implies that the difference of the decimal exponents of adjacent
14703  // table entries must be less than or equal to
14704  //
14705  // floor( (gamma - alpha) * log_10(2) ) = 8.
14706  //
14707  // (A smaller distance gamma-alpha would require a larger table.)
14708 
14709  // NB:
14710  // Actually this function returns c, such that -60 <= e_c + e + 64 <= -34.
14711 
14712  constexpr int kCachedPowersMinDecExp = -300;
14713  constexpr int kCachedPowersDecStep = 8;
14714 
14715  static constexpr std::array<cached_power, 79> kCachedPowers =
14716  {
14717  {
14718  { 0xAB70FE17C79AC6CA, -1060, -300 },
14719  { 0xFF77B1FCBEBCDC4F, -1034, -292 },
14720  { 0xBE5691EF416BD60C, -1007, -284 },
14721  { 0x8DD01FAD907FFC3C, -980, -276 },
14722  { 0xD3515C2831559A83, -954, -268 },
14723  { 0x9D71AC8FADA6C9B5, -927, -260 },
14724  { 0xEA9C227723EE8BCB, -901, -252 },
14725  { 0xAECC49914078536D, -874, -244 },
14726  { 0x823C12795DB6CE57, -847, -236 },
14727  { 0xC21094364DFB5637, -821, -228 },
14728  { 0x9096EA6F3848984F, -794, -220 },
14729  { 0xD77485CB25823AC7, -768, -212 },
14730  { 0xA086CFCD97BF97F4, -741, -204 },
14731  { 0xEF340A98172AACE5, -715, -196 },
14732  { 0xB23867FB2A35B28E, -688, -188 },
14733  { 0x84C8D4DFD2C63F3B, -661, -180 },
14734  { 0xC5DD44271AD3CDBA, -635, -172 },
14735  { 0x936B9FCEBB25C996, -608, -164 },
14736  { 0xDBAC6C247D62A584, -582, -156 },
14737  { 0xA3AB66580D5FDAF6, -555, -148 },
14738  { 0xF3E2F893DEC3F126, -529, -140 },
14739  { 0xB5B5ADA8AAFF80B8, -502, -132 },
14740  { 0x87625F056C7C4A8B, -475, -124 },
14741  { 0xC9BCFF6034C13053, -449, -116 },
14742  { 0x964E858C91BA2655, -422, -108 },
14743  { 0xDFF9772470297EBD, -396, -100 },
14744  { 0xA6DFBD9FB8E5B88F, -369, -92 },
14745  { 0xF8A95FCF88747D94, -343, -84 },
14746  { 0xB94470938FA89BCF, -316, -76 },
14747  { 0x8A08F0F8BF0F156B, -289, -68 },
14748  { 0xCDB02555653131B6, -263, -60 },
14749  { 0x993FE2C6D07B7FAC, -236, -52 },
14750  { 0xE45C10C42A2B3B06, -210, -44 },
14751  { 0xAA242499697392D3, -183, -36 },
14752  { 0xFD87B5F28300CA0E, -157, -28 },
14753  { 0xBCE5086492111AEB, -130, -20 },
14754  { 0x8CBCCC096F5088CC, -103, -12 },
14755  { 0xD1B71758E219652C, -77, -4 },
14756  { 0x9C40000000000000, -50, 4 },
14757  { 0xE8D4A51000000000, -24, 12 },
14758  { 0xAD78EBC5AC620000, 3, 20 },
14759  { 0x813F3978F8940984, 30, 28 },
14760  { 0xC097CE7BC90715B3, 56, 36 },
14761  { 0x8F7E32CE7BEA5C70, 83, 44 },
14762  { 0xD5D238A4ABE98068, 109, 52 },
14763  { 0x9F4F2726179A2245, 136, 60 },
14764  { 0xED63A231D4C4FB27, 162, 68 },
14765  { 0xB0DE65388CC8ADA8, 189, 76 },
14766  { 0x83C7088E1AAB65DB, 216, 84 },
14767  { 0xC45D1DF942711D9A, 242, 92 },
14768  { 0x924D692CA61BE758, 269, 100 },
14769  { 0xDA01EE641A708DEA, 295, 108 },
14770  { 0xA26DA3999AEF774A, 322, 116 },
14771  { 0xF209787BB47D6B85, 348, 124 },
14772  { 0xB454E4A179DD1877, 375, 132 },
14773  { 0x865B86925B9BC5C2, 402, 140 },
14774  { 0xC83553C5C8965D3D, 428, 148 },
14775  { 0x952AB45CFA97A0B3, 455, 156 },
14776  { 0xDE469FBD99A05FE3, 481, 164 },
14777  { 0xA59BC234DB398C25, 508, 172 },
14778  { 0xF6C69A72A3989F5C, 534, 180 },
14779  { 0xB7DCBF5354E9BECE, 561, 188 },
14780  { 0x88FCF317F22241E2, 588, 196 },
14781  { 0xCC20CE9BD35C78A5, 614, 204 },
14782  { 0x98165AF37B2153DF, 641, 212 },
14783  { 0xE2A0B5DC971F303A, 667, 220 },
14784  { 0xA8D9D1535CE3B396, 694, 228 },
14785  { 0xFB9B7CD9A4A7443C, 720, 236 },
14786  { 0xBB764C4CA7A44410, 747, 244 },
14787  { 0x8BAB8EEFB6409C1A, 774, 252 },
14788  { 0xD01FEF10A657842C, 800, 260 },
14789  { 0x9B10A4E5E9913129, 827, 268 },
14790  { 0xE7109BFBA19C0C9D, 853, 276 },
14791  { 0xAC2820D9623BF429, 880, 284 },
14792  { 0x80444B5E7AA7CF85, 907, 292 },
14793  { 0xBF21E44003ACDD2D, 933, 300 },
14794  { 0x8E679C2F5E44FF8F, 960, 308 },
14795  { 0xD433179D9C8CB841, 986, 316 },
14796  { 0x9E19DB92B4E31BA9, 1013, 324 },
14797  }
14798  };
14799 
14800  // This computation gives exactly the same results for k as
14801  // k = ceil((kAlpha - e - 1) * 0.30102999566398114)
14802  // for |e| <= 1500, but doesn't require floating-point operations.
14803  // NB: log_10(2) ~= 78913 / 2^18
14804  JSON_ASSERT(e >= -1500);
14805  JSON_ASSERT(e <= 1500);
14806  const int f = kAlpha - e - 1;
14807  const int k = (f * 78913) / (1 << 18) + static_cast<int>(f > 0);
14808 
14809  const int index = (-kCachedPowersMinDecExp + k + (kCachedPowersDecStep - 1)) / kCachedPowersDecStep;
14810  JSON_ASSERT(index >= 0);
14811  JSON_ASSERT(static_cast<std::size_t>(index) < kCachedPowers.size());
14812 
14813  const cached_power cached = kCachedPowers[static_cast<std::size_t>(index)];
14814  JSON_ASSERT(kAlpha <= cached.e + e + 64);
14815  JSON_ASSERT(kGamma >= cached.e + e + 64);
14816 
14817  return cached;
14818 }
14819 
14820 /*!
14821 For n != 0, returns k, such that pow10 := 10^(k-1) <= n < 10^k.
14822 For n == 0, returns 1 and sets pow10 := 1.
14823 */
14824 inline int find_largest_pow10(const std::uint32_t n, std::uint32_t& pow10)
14825 {
14826  // LCOV_EXCL_START
14827  if (n >= 1000000000)
14828  {
14829  pow10 = 1000000000;
14830  return 10;
14831  }
14832  // LCOV_EXCL_STOP
14833  else if (n >= 100000000)
14834  {
14835  pow10 = 100000000;
14836  return 9;
14837  }
14838  else if (n >= 10000000)
14839  {
14840  pow10 = 10000000;
14841  return 8;
14842  }
14843  else if (n >= 1000000)
14844  {
14845  pow10 = 1000000;
14846  return 7;
14847  }
14848  else if (n >= 100000)
14849  {
14850  pow10 = 100000;
14851  return 6;
14852  }
14853  else if (n >= 10000)
14854  {
14855  pow10 = 10000;
14856  return 5;
14857  }
14858  else if (n >= 1000)
14859  {
14860  pow10 = 1000;
14861  return 4;
14862  }
14863  else if (n >= 100)
14864  {
14865  pow10 = 100;
14866  return 3;
14867  }
14868  else if (n >= 10)
14869  {
14870  pow10 = 10;
14871  return 2;
14872  }
14873  else
14874  {
14875  pow10 = 1;
14876  return 1;
14877  }
14878 }
14879 
14880 inline void grisu2_round(char* buf, int len, std::uint64_t dist, std::uint64_t delta,
14881  std::uint64_t rest, std::uint64_t ten_k)
14882 {
14883  JSON_ASSERT(len >= 1);
14884  JSON_ASSERT(dist <= delta);
14885  JSON_ASSERT(rest <= delta);
14886  JSON_ASSERT(ten_k > 0);
14887 
14888  // <--------------------------- delta ---->
14889  // <---- dist --------->
14890  // --------------[------------------+-------------------]--------------
14891  // M- w M+
14892  //
14893  // ten_k
14894  // <------>
14895  // <---- rest ---->
14896  // --------------[------------------+----+--------------]--------------
14897  // w V
14898  // = buf * 10^k
14899  //
14900  // ten_k represents a unit-in-the-last-place in the decimal representation
14901  // stored in buf.
14902  // Decrement buf by ten_k while this takes buf closer to w.
14903 
14904  // The tests are written in this order to avoid overflow in unsigned
14905  // integer arithmetic.
14906 
14907  while (rest < dist
14908  && delta - rest >= ten_k
14909  && (rest + ten_k < dist || dist - rest > rest + ten_k - dist))
14910  {
14911  JSON_ASSERT(buf[len - 1] != '0');
14912  buf[len - 1]--;
14913  rest += ten_k;
14914  }
14915 }
14916 
14917 /*!
14918 Generates V = buffer * 10^decimal_exponent, such that M- <= V <= M+.
14919 M- and M+ must be normalized and share the same exponent -60 <= e <= -32.
14920 */
14921 inline void grisu2_digit_gen(char* buffer, int& length, int& decimal_exponent,
14922  diyfp M_minus, diyfp w, diyfp M_plus)
14923 {
14924  static_assert(kAlpha >= -60, "internal error");
14925  static_assert(kGamma <= -32, "internal error");
14926 
14927  // Generates the digits (and the exponent) of a decimal floating-point
14928  // number V = buffer * 10^decimal_exponent in the range [M-, M+]. The diyfp's
14929  // w, M- and M+ share the same exponent e, which satisfies alpha <= e <= gamma.
14930  //
14931  // <--------------------------- delta ---->
14932  // <---- dist --------->
14933  // --------------[------------------+-------------------]--------------
14934  // M- w M+
14935  //
14936  // Grisu2 generates the digits of M+ from left to right and stops as soon as
14937  // V is in [M-,M+].
14938 
14939  JSON_ASSERT(M_plus.e >= kAlpha);
14940  JSON_ASSERT(M_plus.e <= kGamma);
14941 
14942  std::uint64_t delta = diyfp::sub(M_plus, M_minus).f; // (significand of (M+ - M-), implicit exponent is e)
14943  std::uint64_t dist = diyfp::sub(M_plus, w ).f; // (significand of (M+ - w ), implicit exponent is e)
14944 
14945  // Split M+ = f * 2^e into two parts p1 and p2 (note: e < 0):
14946  //
14947  // M+ = f * 2^e
14948  // = ((f div 2^-e) * 2^-e + (f mod 2^-e)) * 2^e
14949  // = ((p1 ) * 2^-e + (p2 )) * 2^e
14950  // = p1 + p2 * 2^e
14951 
14952  const diyfp one(std::uint64_t{1} << -M_plus.e, M_plus.e);
14953 
14954  auto p1 = static_cast<std::uint32_t>(M_plus.f >> -one.e); // p1 = f div 2^-e (Since -e >= 32, p1 fits into a 32-bit int.)
14955  std::uint64_t p2 = M_plus.f & (one.f - 1); // p2 = f mod 2^-e
14956 
14957  // 1)
14958  //
14959  // Generate the digits of the integral part p1 = d[n-1]...d[1]d[0]
14960 
14961  JSON_ASSERT(p1 > 0);
14962 
14963  std::uint32_t pow10;
14964  const int k = find_largest_pow10(p1, pow10);
14965 
14966  // 10^(k-1) <= p1 < 10^k, pow10 = 10^(k-1)
14967  //
14968  // p1 = (p1 div 10^(k-1)) * 10^(k-1) + (p1 mod 10^(k-1))
14969  // = (d[k-1] ) * 10^(k-1) + (p1 mod 10^(k-1))
14970  //
14971  // M+ = p1 + p2 * 2^e
14972  // = d[k-1] * 10^(k-1) + (p1 mod 10^(k-1)) + p2 * 2^e
14973  // = d[k-1] * 10^(k-1) + ((p1 mod 10^(k-1)) * 2^-e + p2) * 2^e
14974  // = d[k-1] * 10^(k-1) + ( rest) * 2^e
14975  //
14976  // Now generate the digits d[n] of p1 from left to right (n = k-1,...,0)
14977  //
14978  // p1 = d[k-1]...d[n] * 10^n + d[n-1]...d[0]
14979  //
14980  // but stop as soon as
14981  //
14982  // rest * 2^e = (d[n-1]...d[0] * 2^-e + p2) * 2^e <= delta * 2^e
14983 
14984  int n = k;
14985  while (n > 0)
14986  {
14987  // Invariants:
14988  // M+ = buffer * 10^n + (p1 + p2 * 2^e) (buffer = 0 for n = k)
14989  // pow10 = 10^(n-1) <= p1 < 10^n
14990  //
14991  const std::uint32_t d = p1 / pow10; // d = p1 div 10^(n-1)
14992  const std::uint32_t r = p1 % pow10; // r = p1 mod 10^(n-1)
14993  //
14994  // M+ = buffer * 10^n + (d * 10^(n-1) + r) + p2 * 2^e
14995  // = (buffer * 10 + d) * 10^(n-1) + (r + p2 * 2^e)
14996  //
14997  JSON_ASSERT(d <= 9);
14998  buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
14999  //
15000  // M+ = buffer * 10^(n-1) + (r + p2 * 2^e)
15001  //
15002  p1 = r;
15003  n--;
15004  //
15005  // M+ = buffer * 10^n + (p1 + p2 * 2^e)
15006  // pow10 = 10^n
15007  //
15008 
15009  // Now check if enough digits have been generated.
15010  // Compute
15011  //
15012  // p1 + p2 * 2^e = (p1 * 2^-e + p2) * 2^e = rest * 2^e
15013  //
15014  // Note:
15015  // Since rest and delta share the same exponent e, it suffices to
15016  // compare the significands.
15017  const std::uint64_t rest = (std::uint64_t{p1} << -one.e) + p2;
15018  if (rest <= delta)
15019  {
15020  // V = buffer * 10^n, with M- <= V <= M+.
15021 
15022  decimal_exponent += n;
15023 
15024  // We may now just stop. But instead look if the buffer could be
15025  // decremented to bring V closer to w.
15026  //
15027  // pow10 = 10^n is now 1 ulp in the decimal representation V.
15028  // The rounding procedure works with diyfp's with an implicit
15029  // exponent of e.
15030  //
15031  // 10^n = (10^n * 2^-e) * 2^e = ulp * 2^e
15032  //
15033  const std::uint64_t ten_n = std::uint64_t{pow10} << -one.e;
15034  grisu2_round(buffer, length, dist, delta, rest, ten_n);
15035 
15036  return;
15037  }
15038 
15039  pow10 /= 10;
15040  //
15041  // pow10 = 10^(n-1) <= p1 < 10^n
15042  // Invariants restored.
15043  }
15044 
15045  // 2)
15046  //
15047  // The digits of the integral part have been generated:
15048  //
15049  // M+ = d[k-1]...d[1]d[0] + p2 * 2^e
15050  // = buffer + p2 * 2^e
15051  //
15052  // Now generate the digits of the fractional part p2 * 2^e.
15053  //
15054  // Note:
15055  // No decimal point is generated: the exponent is adjusted instead.
15056  //
15057  // p2 actually represents the fraction
15058  //
15059  // p2 * 2^e
15060  // = p2 / 2^-e
15061  // = d[-1] / 10^1 + d[-2] / 10^2 + ...
15062  //
15063  // Now generate the digits d[-m] of p1 from left to right (m = 1,2,...)
15064  //
15065  // p2 * 2^e = d[-1]d[-2]...d[-m] * 10^-m
15066  // + 10^-m * (d[-m-1] / 10^1 + d[-m-2] / 10^2 + ...)
15067  //
15068  // using
15069  //
15070  // 10^m * p2 = ((10^m * p2) div 2^-e) * 2^-e + ((10^m * p2) mod 2^-e)
15071  // = ( d) * 2^-e + ( r)
15072  //
15073  // or
15074  // 10^m * p2 * 2^e = d + r * 2^e
15075  //
15076  // i.e.
15077  //
15078  // M+ = buffer + p2 * 2^e
15079  // = buffer + 10^-m * (d + r * 2^e)
15080  // = (buffer * 10^m + d) * 10^-m + 10^-m * r * 2^e
15081  //
15082  // and stop as soon as 10^-m * r * 2^e <= delta * 2^e
15083 
15084  JSON_ASSERT(p2 > delta);
15085 
15086  int m = 0;
15087  for (;;)
15088  {
15089  // Invariant:
15090  // M+ = buffer * 10^-m + 10^-m * (d[-m-1] / 10 + d[-m-2] / 10^2 + ...) * 2^e
15091  // = buffer * 10^-m + 10^-m * (p2 ) * 2^e
15092  // = buffer * 10^-m + 10^-m * (1/10 * (10 * p2) ) * 2^e
15093  // = buffer * 10^-m + 10^-m * (1/10 * ((10*p2 div 2^-e) * 2^-e + (10*p2 mod 2^-e)) * 2^e
15094  //
15095  JSON_ASSERT(p2 <= (std::numeric_limits<std::uint64_t>::max)() / 10);
15096  p2 *= 10;
15097  const std::uint64_t d = p2 >> -one.e; // d = (10 * p2) div 2^-e
15098  const std::uint64_t r = p2 & (one.f - 1); // r = (10 * p2) mod 2^-e
15099  //
15100  // M+ = buffer * 10^-m + 10^-m * (1/10 * (d * 2^-e + r) * 2^e
15101  // = buffer * 10^-m + 10^-m * (1/10 * (d + r * 2^e))
15102  // = (buffer * 10 + d) * 10^(-m-1) + 10^(-m-1) * r * 2^e
15103  //
15104  JSON_ASSERT(d <= 9);
15105  buffer[length++] = static_cast<char>('0' + d); // buffer := buffer * 10 + d
15106  //
15107  // M+ = buffer * 10^(-m-1) + 10^(-m-1) * r * 2^e
15108  //
15109  p2 = r;
15110  m++;
15111  //
15112  // M+ = buffer * 10^-m + 10^-m * p2 * 2^e
15113  // Invariant restored.
15114 
15115  // Check if enough digits have been generated.
15116  //
15117  // 10^-m * p2 * 2^e <= delta * 2^e
15118  // p2 * 2^e <= 10^m * delta * 2^e
15119  // p2 <= 10^m * delta
15120  delta *= 10;
15121  dist *= 10;
15122  if (p2 <= delta)
15123  {
15124  break;
15125  }
15126  }
15127 
15128  // V = buffer * 10^-m, with M- <= V <= M+.
15129 
15130  decimal_exponent -= m;
15131 
15132  // 1 ulp in the decimal representation is now 10^-m.
15133  // Since delta and dist are now scaled by 10^m, we need to do the
15134  // same with ulp in order to keep the units in sync.
15135  //
15136  // 10^m * 10^-m = 1 = 2^-e * 2^e = ten_m * 2^e
15137  //
15138  const std::uint64_t ten_m = one.f;
15139  grisu2_round(buffer, length, dist, delta, p2, ten_m);
15140 
15141  // By construction this algorithm generates the shortest possible decimal
15142  // number (Loitsch, Theorem 6.2) which rounds back to w.
15143  // For an input number of precision p, at least
15144  //
15145  // N = 1 + ceil(p * log_10(2))
15146  //
15147  // decimal digits are sufficient to identify all binary floating-point
15148  // numbers (Matula, "In-and-Out conversions").
15149  // This implies that the algorithm does not produce more than N decimal
15150  // digits.
15151  //
15152  // N = 17 for p = 53 (IEEE double precision)
15153  // N = 9 for p = 24 (IEEE single precision)
15154 }
15155 
15156 /*!
15157 v = buf * 10^decimal_exponent
15158 len is the length of the buffer (number of decimal digits)
15159 The buffer must be large enough, i.e. >= max_digits10.
15160 */
15161 JSON_HEDLEY_NON_NULL(1)
15162 inline void grisu2(char* buf, int& len, int& decimal_exponent,
15163  diyfp m_minus, diyfp v, diyfp m_plus)
15164 {
15165  JSON_ASSERT(m_plus.e == m_minus.e);
15166  JSON_ASSERT(m_plus.e == v.e);
15167 
15168  // --------(-----------------------+-----------------------)-------- (A)
15169  // m- v m+
15170  //
15171  // --------------------(-----------+-----------------------)-------- (B)
15172  // m- v m+
15173  //
15174  // First scale v (and m- and m+) such that the exponent is in the range
15175  // [alpha, gamma].
15176 
15177  const cached_power cached = get_cached_power_for_binary_exponent(m_plus.e);
15178 
15179  const diyfp c_minus_k(cached.f, cached.e); // = c ~= 10^-k
15180 
15181  // The exponent of the products is = v.e + c_minus_k.e + q and is in the range [alpha,gamma]
15182  const diyfp w = diyfp::mul(v, c_minus_k);
15183  const diyfp w_minus = diyfp::mul(m_minus, c_minus_k);
15184  const diyfp w_plus = diyfp::mul(m_plus, c_minus_k);
15185 
15186  // ----(---+---)---------------(---+---)---------------(---+---)----
15187  // w- w w+
15188  // = c*m- = c*v = c*m+
15189  //
15190  // diyfp::mul rounds its result and c_minus_k is approximated too. w, w- and
15191  // w+ are now off by a small amount.
15192  // In fact:
15193  //
15194  // w - v * 10^k < 1 ulp
15195  //
15196  // To account for this inaccuracy, add resp. subtract 1 ulp.
15197  //
15198  // --------+---[---------------(---+---)---------------]---+--------
15199  // w- M- w M+ w+
15200  //
15201  // Now any number in [M-, M+] (bounds included) will round to w when input,
15202  // regardless of how the input rounding algorithm breaks ties.
15203  //
15204  // And digit_gen generates the shortest possible such number in [M-, M+].
15205  // Note that this does not mean that Grisu2 always generates the shortest
15206  // possible number in the interval (m-, m+).
15207  const diyfp M_minus(w_minus.f + 1, w_minus.e);
15208  const diyfp M_plus (w_plus.f - 1, w_plus.e );
15209 
15210  decimal_exponent = -cached.k; // = -(-k) = k
15211 
15212  grisu2_digit_gen(buf, len, decimal_exponent, M_minus, w, M_plus);
15213 }
15214 
15215 /*!
15216 v = buf * 10^decimal_exponent
15217 len is the length of the buffer (number of decimal digits)
15218 The buffer must be large enough, i.e. >= max_digits10.
15219 */
15220 template<typename FloatType>
15221 JSON_HEDLEY_NON_NULL(1)
15222 void grisu2(char* buf, int& len, int& decimal_exponent, FloatType value)
15223 {
15224  static_assert(diyfp::kPrecision >= std::numeric_limits<FloatType>::digits + 3,
15225  "internal error: not enough precision");
15226 
15227  JSON_ASSERT(std::isfinite(value));
15228  JSON_ASSERT(value > 0);
15229 
15230  // If the neighbors (and boundaries) of 'value' are always computed for double-precision
15231  // numbers, all float's can be recovered using strtod (and strtof). However, the resulting
15232  // decimal representations are not exactly "short".
15233  //
15234  // The documentation for 'std::to_chars' (https://en.cppreference.com/w/cpp/utility/to_chars)
15235  // says "value is converted to a string as if by std::sprintf in the default ("C") locale"
15236  // and since sprintf promotes float's to double's, I think this is exactly what 'std::to_chars'
15237  // does.
15238  // On the other hand, the documentation for 'std::to_chars' requires that "parsing the
15239  // representation using the corresponding std::from_chars function recovers value exactly". That
15240  // indicates that single precision floating-point numbers should be recovered using
15241  // 'std::strtof'.
15242  //
15243  // NB: If the neighbors are computed for single-precision numbers, there is a single float
15244  // (7.0385307e-26f) which can't be recovered using strtod. The resulting double precision
15245  // value is off by 1 ulp.
15246 #if 0
15247  const boundaries w = compute_boundaries(static_cast<double>(value));
15248 #else
15249  const boundaries w = compute_boundaries(value);
15250 #endif
15251 
15252  grisu2(buf, len, decimal_exponent, w.minus, w.w, w.plus);
15253 }
15254 
15255 /*!
15256 @brief appends a decimal representation of e to buf
15257 @return a pointer to the element following the exponent.
15258 @pre -1000 < e < 1000
15259 */
15260 JSON_HEDLEY_NON_NULL(1)
15261 JSON_HEDLEY_RETURNS_NON_NULL
15262 inline char* append_exponent(char* buf, int e)
15263 {
15264  JSON_ASSERT(e > -1000);
15265  JSON_ASSERT(e < 1000);
15266 
15267  if (e < 0)
15268  {
15269  e = -e;
15270  *buf++ = '-';
15271  }
15272  else
15273  {
15274  *buf++ = '+';
15275  }
15276 
15277  auto k = static_cast<std::uint32_t>(e);
15278  if (k < 10)
15279  {
15280  // Always print at least two digits in the exponent.
15281  // This is for compatibility with printf("%g").
15282  *buf++ = '0';
15283  *buf++ = static_cast<char>('0' + k);
15284  }
15285  else if (k < 100)
15286  {
15287  *buf++ = static_cast<char>('0' + k / 10);
15288  k %= 10;
15289  *buf++ = static_cast<char>('0' + k);
15290  }
15291  else
15292  {
15293  *buf++ = static_cast<char>('0' + k / 100);
15294  k %= 100;
15295  *buf++ = static_cast<char>('0' + k / 10);
15296  k %= 10;
15297  *buf++ = static_cast<char>('0' + k);
15298  }
15299 
15300  return buf;
15301 }
15302 
15303 /*!
15304 @brief prettify v = buf * 10^decimal_exponent
15305 
15306 If v is in the range [10^min_exp, 10^max_exp) it will be printed in fixed-point
15307 notation. Otherwise it will be printed in exponential notation.
15308 
15309 @pre min_exp < 0
15310 @pre max_exp > 0
15311 */
15312 JSON_HEDLEY_NON_NULL(1)
15313 JSON_HEDLEY_RETURNS_NON_NULL
15314 inline char* format_buffer(char* buf, int len, int decimal_exponent,
15315  int min_exp, int max_exp)
15316 {
15317  JSON_ASSERT(min_exp < 0);
15318  JSON_ASSERT(max_exp > 0);
15319 
15320  const int k = len;
15321  const int n = len + decimal_exponent;
15322 
15323  // v = buf * 10^(n-k)
15324  // k is the length of the buffer (number of decimal digits)
15325  // n is the position of the decimal point relative to the start of the buffer.
15326 
15327  if (k <= n && n <= max_exp)
15328  {
15329  // digits[000]
15330  // len <= max_exp + 2
15331 
15332  std::memset(buf + k, '0', static_cast<size_t>(n) - static_cast<size_t>(k));
15333  // Make it look like a floating-point number (#362, #378)
15334  buf[n + 0] = '.';
15335  buf[n + 1] = '0';
15336  return buf + (static_cast<size_t>(n) + 2);
15337  }
15338 
15339  if (0 < n && n <= max_exp)
15340  {
15341  // dig.its
15342  // len <= max_digits10 + 1
15343 
15344  JSON_ASSERT(k > n);
15345 
15346  std::memmove(buf + (static_cast<size_t>(n) + 1), buf + n, static_cast<size_t>(k) - static_cast<size_t>(n));
15347  buf[n] = '.';
15348  return buf + (static_cast<size_t>(k) + 1U);
15349  }
15350 
15351  if (min_exp < n && n <= 0)
15352  {
15353  // 0.[000]digits
15354  // len <= 2 + (-min_exp - 1) + max_digits10
15355 
15356  std::memmove(buf + (2 + static_cast<size_t>(-n)), buf, static_cast<size_t>(k));
15357  buf[0] = '0';
15358  buf[1] = '.';
15359  std::memset(buf + 2, '0', static_cast<size_t>(-n));
15360  return buf + (2U + static_cast<size_t>(-n) + static_cast<size_t>(k));
15361  }
15362 
15363  if (k == 1)
15364  {
15365  // dE+123
15366  // len <= 1 + 5
15367 
15368  buf += 1;
15369  }
15370  else
15371  {
15372  // d.igitsE+123
15373  // len <= max_digits10 + 1 + 5
15374 
15375  std::memmove(buf + 2, buf + 1, static_cast<size_t>(k) - 1);
15376  buf[1] = '.';
15377  buf += 1 + static_cast<size_t>(k);
15378  }
15379 
15380  *buf++ = 'e';
15381  return append_exponent(buf, n - 1);
15382 }
15383 
15384 } // namespace dtoa_impl
15385 
15386 /*!
15387 @brief generates a decimal representation of the floating-point number value in [first, last).
15388 
15389 The format of the resulting decimal representation is similar to printf's %g
15390 format. Returns an iterator pointing past-the-end of the decimal representation.
15391 
15392 @note The input number must be finite, i.e. NaN's and Inf's are not supported.
15393 @note The buffer must be large enough.
15394 @note The result is NOT null-terminated.
15395 */
15396 template<typename FloatType>
15397 JSON_HEDLEY_NON_NULL(1, 2)
15398 JSON_HEDLEY_RETURNS_NON_NULL
15399 char* to_chars(char* first, const char* last, FloatType value)
15400 {
15401  static_cast<void>(last); // maybe unused - fix warning
15402  JSON_ASSERT(std::isfinite(value));
15403 
15404  // Use signbit(value) instead of (value < 0) since signbit works for -0.
15405  if (std::signbit(value))
15406  {
15407  value = -value;
15408  *first++ = '-';
15409  }
15410 
15411  if (value == 0) // +-0
15412  {
15413  *first++ = '0';
15414  // Make it look like a floating-point number (#362, #378)
15415  *first++ = '.';
15416  *first++ = '0';
15417  return first;
15418  }
15419 
15420  JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10);
15421 
15422  // Compute v = buffer * 10^decimal_exponent.
15423  // The decimal digits are stored in the buffer, which needs to be interpreted
15424  // as an unsigned decimal integer.
15425  // len is the length of the buffer, i.e. the number of decimal digits.
15426  int len = 0;
15427  int decimal_exponent = 0;
15428  dtoa_impl::grisu2(first, len, decimal_exponent, value);
15429 
15430  JSON_ASSERT(len <= std::numeric_limits<FloatType>::max_digits10);
15431 
15432  // Format the buffer like printf("%.*g", prec, value)
15433  constexpr int kMinExp = -4;
15434  // Use digits10 here to increase compatibility with version 2.
15435  constexpr int kMaxExp = std::numeric_limits<FloatType>::digits10;
15436 
15437  JSON_ASSERT(last - first >= kMaxExp + 2);
15438  JSON_ASSERT(last - first >= 2 + (-kMinExp - 1) + std::numeric_limits<FloatType>::max_digits10);
15439  JSON_ASSERT(last - first >= std::numeric_limits<FloatType>::max_digits10 + 6);
15440 
15441  return dtoa_impl::format_buffer(first, len, decimal_exponent, kMinExp, kMaxExp);
15442 }
15443 
15444 } // namespace detail
15445 } // namespace nlohmann
15446 
15447 // #include <nlohmann/detail/exceptions.hpp>
15448 
15449 // #include <nlohmann/detail/macro_scope.hpp>
15450 
15451 // #include <nlohmann/detail/meta/cpp_future.hpp>
15452 
15453 // #include <nlohmann/detail/output/binary_writer.hpp>
15454 
15455 // #include <nlohmann/detail/output/output_adapters.hpp>
15456 
15457 // #include <nlohmann/detail/value_t.hpp>
15458 
15459 
15460 namespace nlohmann
15461 {
15462 namespace detail
15463 {
15464 ///////////////////
15465 // serialization //
15466 ///////////////////
15467 
15468 /// how to treat decoding errors
15470 {
15471  strict, ///< throw a type_error exception in case of invalid UTF-8
15472  replace, ///< replace invalid UTF-8 sequences with U+FFFD
15473  ignore ///< ignore invalid UTF-8 sequences
15474 };
15475 
15476 template<typename BasicJsonType>
15478 {
15479  using string_t = typename BasicJsonType::string_t;
15480  using number_float_t = typename BasicJsonType::number_float_t;
15481  using number_integer_t = typename BasicJsonType::number_integer_t;
15482  using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
15483  using binary_char_t = typename BasicJsonType::binary_t::value_type;
15484  static constexpr std::uint8_t UTF8_ACCEPT = 0;
15485  static constexpr std::uint8_t UTF8_REJECT = 1;
15486 
15487  public:
15488  /*!
15489  @param[in] s output stream to serialize to
15490  @param[in] ichar indentation character to use
15491  @param[in] error_handler_ how to react on decoding errors
15492  */
15493  serializer(output_adapter_t<char> s, const char ichar,
15494  error_handler_t error_handler_ = error_handler_t::strict)
15495  : o(std::move(s))
15496  , loc(std::localeconv())
15497  , thousands_sep(loc->thousands_sep == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->thousands_sep)))
15498  , decimal_point(loc->decimal_point == nullptr ? '\0' : std::char_traits<char>::to_char_type(* (loc->decimal_point)))
15499  , indent_char(ichar)
15500  , indent_string(512, indent_char)
15501  , error_handler(error_handler_)
15502  {}
15503 
15504  // delete because of pointer members
15505  serializer(const serializer&) = delete;
15506  serializer& operator=(const serializer&) = delete;
15507  serializer(serializer&&) = delete;
15508  serializer& operator=(serializer&&) = delete;
15509  ~serializer() = default;
15510 
15511  /*!
15512  @brief internal implementation of the serialization function
15513 
15514  This function is called by the public member function dump and organizes
15515  the serialization internally. The indentation level is propagated as
15516  additional parameter. In case of arrays and objects, the function is
15517  called recursively.
15518 
15519  - strings and object keys are escaped using `escape_string()`
15520  - integer numbers are converted implicitly via `operator<<`
15521  - floating-point numbers are converted to a string using `"%g"` format
15522  - binary values are serialized as objects containing the subtype and the
15523  byte array
15524 
15525  @param[in] val value to serialize
15526  @param[in] pretty_print whether the output shall be pretty-printed
15527  @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
15528  in the output are escaped with `\uXXXX` sequences, and the result consists
15529  of ASCII characters only.
15530  @param[in] indent_step the indent level
15531  @param[in] current_indent the current indent level (only used internally)
15532  */
15533  void dump(const BasicJsonType& val,
15534  const bool pretty_print,
15535  const bool ensure_ascii,
15536  const unsigned int indent_step,
15537  const unsigned int current_indent = 0)
15538  {
15539  switch (val.m_type)
15540  {
15541  case value_t::object:
15542  {
15543  if (val.m_value.object->empty())
15544  {
15545  o->write_characters("{}", 2);
15546  return;
15547  }
15548 
15549  if (pretty_print)
15550  {
15551  o->write_characters("{\n", 2);
15552 
15553  // variable to hold indentation for recursive calls
15554  const auto new_indent = current_indent + indent_step;
15555  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
15556  {
15557  indent_string.resize(indent_string.size() * 2, ' ');
15558  }
15559 
15560  // first n-1 elements
15561  auto i = val.m_value.object->cbegin();
15562  for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
15563  {
15564  o->write_characters(indent_string.c_str(), new_indent);
15565  o->write_character('\"');
15566  dump_escaped(i->first, ensure_ascii);
15567  o->write_characters("\": ", 3);
15568  dump(i->second, true, ensure_ascii, indent_step, new_indent);
15569  o->write_characters(",\n", 2);
15570  }
15571 
15572  // last element
15573  JSON_ASSERT(i != val.m_value.object->cend());
15574  JSON_ASSERT(std::next(i) == val.m_value.object->cend());
15575  o->write_characters(indent_string.c_str(), new_indent);
15576  o->write_character('\"');
15577  dump_escaped(i->first, ensure_ascii);
15578  o->write_characters("\": ", 3);
15579  dump(i->second, true, ensure_ascii, indent_step, new_indent);
15580 
15581  o->write_character('\n');
15582  o->write_characters(indent_string.c_str(), current_indent);
15583  o->write_character('}');
15584  }
15585  else
15586  {
15587  o->write_character('{');
15588 
15589  // first n-1 elements
15590  auto i = val.m_value.object->cbegin();
15591  for (std::size_t cnt = 0; cnt < val.m_value.object->size() - 1; ++cnt, ++i)
15592  {
15593  o->write_character('\"');
15594  dump_escaped(i->first, ensure_ascii);
15595  o->write_characters("\":", 2);
15596  dump(i->second, false, ensure_ascii, indent_step, current_indent);
15597  o->write_character(',');
15598  }
15599 
15600  // last element
15601  JSON_ASSERT(i != val.m_value.object->cend());
15602  JSON_ASSERT(std::next(i) == val.m_value.object->cend());
15603  o->write_character('\"');
15604  dump_escaped(i->first, ensure_ascii);
15605  o->write_characters("\":", 2);
15606  dump(i->second, false, ensure_ascii, indent_step, current_indent);
15607 
15608  o->write_character('}');
15609  }
15610 
15611  return;
15612  }
15613 
15614  case value_t::array:
15615  {
15616  if (val.m_value.array->empty())
15617  {
15618  o->write_characters("[]", 2);
15619  return;
15620  }
15621 
15622  if (pretty_print)
15623  {
15624  o->write_characters("[\n", 2);
15625 
15626  // variable to hold indentation for recursive calls
15627  const auto new_indent = current_indent + indent_step;
15628  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
15629  {
15630  indent_string.resize(indent_string.size() * 2, ' ');
15631  }
15632 
15633  // first n-1 elements
15634  for (auto i = val.m_value.array->cbegin();
15635  i != val.m_value.array->cend() - 1; ++i)
15636  {
15637  o->write_characters(indent_string.c_str(), new_indent);
15638  dump(*i, true, ensure_ascii, indent_step, new_indent);
15639  o->write_characters(",\n", 2);
15640  }
15641 
15642  // last element
15643  JSON_ASSERT(!val.m_value.array->empty());
15644  o->write_characters(indent_string.c_str(), new_indent);
15645  dump(val.m_value.array->back(), true, ensure_ascii, indent_step, new_indent);
15646 
15647  o->write_character('\n');
15648  o->write_characters(indent_string.c_str(), current_indent);
15649  o->write_character(']');
15650  }
15651  else
15652  {
15653  o->write_character('[');
15654 
15655  // first n-1 elements
15656  for (auto i = val.m_value.array->cbegin();
15657  i != val.m_value.array->cend() - 1; ++i)
15658  {
15659  dump(*i, false, ensure_ascii, indent_step, current_indent);
15660  o->write_character(',');
15661  }
15662 
15663  // last element
15664  JSON_ASSERT(!val.m_value.array->empty());
15665  dump(val.m_value.array->back(), false, ensure_ascii, indent_step, current_indent);
15666 
15667  o->write_character(']');
15668  }
15669 
15670  return;
15671  }
15672 
15673  case value_t::string:
15674  {
15675  o->write_character('\"');
15676  dump_escaped(*val.m_value.string, ensure_ascii);
15677  o->write_character('\"');
15678  return;
15679  }
15680 
15681  case value_t::binary:
15682  {
15683  if (pretty_print)
15684  {
15685  o->write_characters("{\n", 2);
15686 
15687  // variable to hold indentation for recursive calls
15688  const auto new_indent = current_indent + indent_step;
15689  if (JSON_HEDLEY_UNLIKELY(indent_string.size() < new_indent))
15690  {
15691  indent_string.resize(indent_string.size() * 2, ' ');
15692  }
15693 
15694  o->write_characters(indent_string.c_str(), new_indent);
15695 
15696  o->write_characters("\"bytes\": [", 10);
15697 
15698  if (!val.m_value.binary->empty())
15699  {
15700  for (auto i = val.m_value.binary->cbegin();
15701  i != val.m_value.binary->cend() - 1; ++i)
15702  {
15703  dump_integer(*i);
15704  o->write_characters(", ", 2);
15705  }
15706  dump_integer(val.m_value.binary->back());
15707  }
15708 
15709  o->write_characters("],\n", 3);
15710  o->write_characters(indent_string.c_str(), new_indent);
15711 
15712  o->write_characters("\"subtype\": ", 11);
15713  if (val.m_value.binary->has_subtype())
15714  {
15715  dump_integer(val.m_value.binary->subtype());
15716  }
15717  else
15718  {
15719  o->write_characters("null", 4);
15720  }
15721  o->write_character('\n');
15722  o->write_characters(indent_string.c_str(), current_indent);
15723  o->write_character('}');
15724  }
15725  else
15726  {
15727  o->write_characters("{\"bytes\":[", 10);
15728 
15729  if (!val.m_value.binary->empty())
15730  {
15731  for (auto i = val.m_value.binary->cbegin();
15732  i != val.m_value.binary->cend() - 1; ++i)
15733  {
15734  dump_integer(*i);
15735  o->write_character(',');
15736  }
15737  dump_integer(val.m_value.binary->back());
15738  }
15739 
15740  o->write_characters("],\"subtype\":", 12);
15741  if (val.m_value.binary->has_subtype())
15742  {
15743  dump_integer(val.m_value.binary->subtype());
15744  o->write_character('}');
15745  }
15746  else
15747  {
15748  o->write_characters("null}", 5);
15749  }
15750  }
15751  return;
15752  }
15753 
15754  case value_t::boolean:
15755  {
15756  if (val.m_value.boolean)
15757  {
15758  o->write_characters("true", 4);
15759  }
15760  else
15761  {
15762  o->write_characters("false", 5);
15763  }
15764  return;
15765  }
15766 
15768  {
15769  dump_integer(val.m_value.number_integer);
15770  return;
15771  }
15772 
15774  {
15775  dump_integer(val.m_value.number_unsigned);
15776  return;
15777  }
15778 
15779  case value_t::number_float:
15780  {
15781  dump_float(val.m_value.number_float);
15782  return;
15783  }
15784 
15785  case value_t::discarded:
15786  {
15787  o->write_characters("<discarded>", 11);
15788  return;
15789  }
15790 
15791  case value_t::null:
15792  {
15793  o->write_characters("null", 4);
15794  return;
15795  }
15796 
15797  default: // LCOV_EXCL_LINE
15798  JSON_ASSERT(false); // LCOV_EXCL_LINE
15799  }
15800  }
15801 
15802  private:
15803  /*!
15804  @brief dump escaped string
15805 
15806  Escape a string by replacing certain special characters by a sequence of an
15807  escape character (backslash) and another character and other control
15808  characters by a sequence of "\u" followed by a four-digit hex
15809  representation. The escaped string is written to output stream @a o.
15810 
15811  @param[in] s the string to escape
15812  @param[in] ensure_ascii whether to escape non-ASCII characters with
15813  \uXXXX sequences
15814 
15815  @complexity Linear in the length of string @a s.
15816  */
15817  void dump_escaped(const string_t& s, const bool ensure_ascii)
15818  {
15819  std::uint32_t codepoint;
15820  std::uint8_t state = UTF8_ACCEPT;
15821  std::size_t bytes = 0; // number of bytes written to string_buffer
15822 
15823  // number of bytes written at the point of the last valid byte
15824  std::size_t bytes_after_last_accept = 0;
15825  std::size_t undumped_chars = 0;
15826 
15827  for (std::size_t i = 0; i < s.size(); ++i)
15828  {
15829  const auto byte = static_cast<uint8_t>(s[i]);
15830 
15831  switch (decode(state, codepoint, byte))
15832  {
15833  case UTF8_ACCEPT: // decode found a new code point
15834  {
15835  switch (codepoint)
15836  {
15837  case 0x08: // backspace
15838  {
15839  string_buffer[bytes++] = '\\';
15840  string_buffer[bytes++] = 'b';
15841  break;
15842  }
15843 
15844  case 0x09: // horizontal tab
15845  {
15846  string_buffer[bytes++] = '\\';
15847  string_buffer[bytes++] = 't';
15848  break;
15849  }
15850 
15851  case 0x0A: // newline
15852  {
15853  string_buffer[bytes++] = '\\';
15854  string_buffer[bytes++] = 'n';
15855  break;
15856  }
15857 
15858  case 0x0C: // formfeed
15859  {
15860  string_buffer[bytes++] = '\\';
15861  string_buffer[bytes++] = 'f';
15862  break;
15863  }
15864 
15865  case 0x0D: // carriage return
15866  {
15867  string_buffer[bytes++] = '\\';
15868  string_buffer[bytes++] = 'r';
15869  break;
15870  }
15871 
15872  case 0x22: // quotation mark
15873  {
15874  string_buffer[bytes++] = '\\';
15875  string_buffer[bytes++] = '\"';
15876  break;
15877  }
15878 
15879  case 0x5C: // reverse solidus
15880  {
15881  string_buffer[bytes++] = '\\';
15882  string_buffer[bytes++] = '\\';
15883  break;
15884  }
15885 
15886  default:
15887  {
15888  // escape control characters (0x00..0x1F) or, if
15889  // ensure_ascii parameter is used, non-ASCII characters
15890  if ((codepoint <= 0x1F) || (ensure_ascii && (codepoint >= 0x7F)))
15891  {
15892  if (codepoint <= 0xFFFF)
15893  {
15894  (std::snprintf)(string_buffer.data() + bytes, 7, "\\u%04x",
15895  static_cast<std::uint16_t>(codepoint));
15896  bytes += 6;
15897  }
15898  else
15899  {
15900  (std::snprintf)(string_buffer.data() + bytes, 13, "\\u%04x\\u%04x",
15901  static_cast<std::uint16_t>(0xD7C0u + (codepoint >> 10u)),
15902  static_cast<std::uint16_t>(0xDC00u + (codepoint & 0x3FFu)));
15903  bytes += 12;
15904  }
15905  }
15906  else
15907  {
15908  // copy byte to buffer (all previous bytes
15909  // been copied have in default case above)
15910  string_buffer[bytes++] = s[i];
15911  }
15912  break;
15913  }
15914  }
15915 
15916  // write buffer and reset index; there must be 13 bytes
15917  // left, as this is the maximal number of bytes to be
15918  // written ("\uxxxx\uxxxx\0") for one code point
15919  if (string_buffer.size() - bytes < 13)
15920  {
15921  o->write_characters(string_buffer.data(), bytes);
15922  bytes = 0;
15923  }
15924 
15925  // remember the byte position of this accept
15926  bytes_after_last_accept = bytes;
15927  undumped_chars = 0;
15928  break;
15929  }
15930 
15931  case UTF8_REJECT: // decode found invalid UTF-8 byte
15932  {
15933  switch (error_handler)
15934  {
15936  {
15937  std::string sn(3, '\0');
15938  (std::snprintf)(&sn[0], sn.size(), "%.2X", byte);
15939  JSON_THROW(type_error::create(316, "invalid UTF-8 byte at index " + std::to_string(i) + ": 0x" + sn));
15940  }
15941 
15944  {
15945  // in case we saw this character the first time, we
15946  // would like to read it again, because the byte
15947  // may be OK for itself, but just not OK for the
15948  // previous sequence
15949  if (undumped_chars > 0)
15950  {
15951  --i;
15952  }
15953 
15954  // reset length buffer to the last accepted index;
15955  // thus removing/ignoring the invalid characters
15956  bytes = bytes_after_last_accept;
15957 
15959  {
15960  // add a replacement character
15961  if (ensure_ascii)
15962  {
15963  string_buffer[bytes++] = '\\';
15964  string_buffer[bytes++] = 'u';
15965  string_buffer[bytes++] = 'f';
15966  string_buffer[bytes++] = 'f';
15967  string_buffer[bytes++] = 'f';
15968  string_buffer[bytes++] = 'd';
15969  }
15970  else
15971  {
15975  }
15976 
15977  // write buffer and reset index; there must be 13 bytes
15978  // left, as this is the maximal number of bytes to be
15979  // written ("\uxxxx\uxxxx\0") for one code point
15980  if (string_buffer.size() - bytes < 13)
15981  {
15982  o->write_characters(string_buffer.data(), bytes);
15983  bytes = 0;
15984  }
15985 
15986  bytes_after_last_accept = bytes;
15987  }
15988 
15989  undumped_chars = 0;
15990 
15991  // continue processing the string
15992  state = UTF8_ACCEPT;
15993  break;
15994  }
15995 
15996  default: // LCOV_EXCL_LINE
15997  JSON_ASSERT(false); // LCOV_EXCL_LINE
15998  }
15999  break;
16000  }
16001 
16002  default: // decode found yet incomplete multi-byte code point
16003  {
16004  if (!ensure_ascii)
16005  {
16006  // code point will not be escaped - copy byte to buffer
16007  string_buffer[bytes++] = s[i];
16008  }
16009  ++undumped_chars;
16010  break;
16011  }
16012  }
16013  }
16014 
16015  // we finished processing the string
16016  if (JSON_HEDLEY_LIKELY(state == UTF8_ACCEPT))
16017  {
16018  // write buffer
16019  if (bytes > 0)
16020  {
16021  o->write_characters(string_buffer.data(), bytes);
16022  }
16023  }
16024  else
16025  {
16026  // we finish reading, but do not accept: string was incomplete
16027  switch (error_handler)
16028  {
16030  {
16031  std::string sn(3, '\0');
16032  (std::snprintf)(&sn[0], sn.size(), "%.2X", static_cast<std::uint8_t>(s.back()));
16033  JSON_THROW(type_error::create(316, "incomplete UTF-8 string; last byte: 0x" + sn));
16034  }
16035 
16037  {
16038  // write all accepted bytes
16039  o->write_characters(string_buffer.data(), bytes_after_last_accept);
16040  break;
16041  }
16042 
16044  {
16045  // write all accepted bytes
16046  o->write_characters(string_buffer.data(), bytes_after_last_accept);
16047  // add a replacement character
16048  if (ensure_ascii)
16049  {
16050  o->write_characters("\\ufffd", 6);
16051  }
16052  else
16053  {
16054  o->write_characters("\xEF\xBF\xBD", 3);
16055  }
16056  break;
16057  }
16058 
16059  default: // LCOV_EXCL_LINE
16060  JSON_ASSERT(false); // LCOV_EXCL_LINE
16061  }
16062  }
16063  }
16064 
16065  /*!
16066  @brief count digits
16067 
16068  Count the number of decimal (base 10) digits for an input unsigned integer.
16069 
16070  @param[in] x unsigned integer number to count its digits
16071  @return number of decimal digits
16072  */
16073  inline unsigned int count_digits(number_unsigned_t x) noexcept
16074  {
16075  unsigned int n_digits = 1;
16076  for (;;)
16077  {
16078  if (x < 10)
16079  {
16080  return n_digits;
16081  }
16082  if (x < 100)
16083  {
16084  return n_digits + 1;
16085  }
16086  if (x < 1000)
16087  {
16088  return n_digits + 2;
16089  }
16090  if (x < 10000)
16091  {
16092  return n_digits + 3;
16093  }
16094  x = x / 10000u;
16095  n_digits += 4;
16096  }
16097  }
16098 
16099  /*!
16100  @brief dump an integer
16101 
16102  Dump a given integer to output stream @a o. Works internally with
16103  @a number_buffer.
16104 
16105  @param[in] x integer number (signed or unsigned) to dump
16106  @tparam NumberType either @a number_integer_t or @a number_unsigned_t
16107  */
16108  template < typename NumberType, detail::enable_if_t <
16109  std::is_same<NumberType, number_unsigned_t>::value ||
16110  std::is_same<NumberType, number_integer_t>::value ||
16111  std::is_same<NumberType, binary_char_t>::value,
16112  int > = 0 >
16113  void dump_integer(NumberType x)
16114  {
16115  static constexpr std::array<std::array<char, 2>, 100> digits_to_99
16116  {
16117  {
16118  {{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
16119  {{'1', '0'}}, {{'1', '1'}}, {{'1', '2'}}, {{'1', '3'}}, {{'1', '4'}}, {{'1', '5'}}, {{'1', '6'}}, {{'1', '7'}}, {{'1', '8'}}, {{'1', '9'}},
16120  {{'2', '0'}}, {{'2', '1'}}, {{'2', '2'}}, {{'2', '3'}}, {{'2', '4'}}, {{'2', '5'}}, {{'2', '6'}}, {{'2', '7'}}, {{'2', '8'}}, {{'2', '9'}},
16121  {{'3', '0'}}, {{'3', '1'}}, {{'3', '2'}}, {{'3', '3'}}, {{'3', '4'}}, {{'3', '5'}}, {{'3', '6'}}, {{'3', '7'}}, {{'3', '8'}}, {{'3', '9'}},
16122  {{'4', '0'}}, {{'4', '1'}}, {{'4', '2'}}, {{'4', '3'}}, {{'4', '4'}}, {{'4', '5'}}, {{'4', '6'}}, {{'4', '7'}}, {{'4', '8'}}, {{'4', '9'}},
16123  {{'5', '0'}}, {{'5', '1'}}, {{'5', '2'}}, {{'5', '3'}}, {{'5', '4'}}, {{'5', '5'}}, {{'5', '6'}}, {{'5', '7'}}, {{'5', '8'}}, {{'5', '9'}},
16124  {{'6', '0'}}, {{'6', '1'}}, {{'6', '2'}}, {{'6', '3'}}, {{'6', '4'}}, {{'6', '5'}}, {{'6', '6'}}, {{'6', '7'}}, {{'6', '8'}}, {{'6', '9'}},
16125  {{'7', '0'}}, {{'7', '1'}}, {{'7', '2'}}, {{'7', '3'}}, {{'7', '4'}}, {{'7', '5'}}, {{'7', '6'}}, {{'7', '7'}}, {{'7', '8'}}, {{'7', '9'}},
16126  {{'8', '0'}}, {{'8', '1'}}, {{'8', '2'}}, {{'8', '3'}}, {{'8', '4'}}, {{'8', '5'}}, {{'8', '6'}}, {{'8', '7'}}, {{'8', '8'}}, {{'8', '9'}},
16127  {{'9', '0'}}, {{'9', '1'}}, {{'9', '2'}}, {{'9', '3'}}, {{'9', '4'}}, {{'9', '5'}}, {{'9', '6'}}, {{'9', '7'}}, {{'9', '8'}}, {{'9', '9'}},
16128  }
16129  };
16130 
16131  // special case for "0"
16132  if (x == 0)
16133  {
16134  o->write_character('0');
16135  return;
16136  }
16137 
16138  // use a pointer to fill the buffer
16139  auto buffer_ptr = number_buffer.begin();
16140 
16141  const bool is_negative = std::is_same<NumberType, number_integer_t>::value && !(x >= 0); // see issue #755
16142  number_unsigned_t abs_value;
16143 
16144  unsigned int n_chars;
16145 
16146  if (is_negative)
16147  {
16148  *buffer_ptr = '-';
16149  abs_value = remove_sign(static_cast<number_integer_t>(x));
16150 
16151  // account one more byte for the minus sign
16152  n_chars = 1 + count_digits(abs_value);
16153  }
16154  else
16155  {
16156  abs_value = static_cast<number_unsigned_t>(x);
16157  n_chars = count_digits(abs_value);
16158  }
16159 
16160  // spare 1 byte for '\0'
16161  JSON_ASSERT(n_chars < number_buffer.size() - 1);
16162 
16163  // jump to the end to generate the string from backward
16164  // so we later avoid reversing the result
16165  buffer_ptr += n_chars;
16166 
16167  // Fast int2ascii implementation inspired by "Fastware" talk by Andrei Alexandrescu
16168  // See: https://www.youtube.com/watch?v=o4-CwDo2zpg
16169  while (abs_value >= 100)
16170  {
16171  const auto digits_index = static_cast<unsigned>((abs_value % 100));
16172  abs_value /= 100;
16173  *(--buffer_ptr) = digits_to_99[digits_index][1];
16174  *(--buffer_ptr) = digits_to_99[digits_index][0];
16175  }
16176 
16177  if (abs_value >= 10)
16178  {
16179  const auto digits_index = static_cast<unsigned>(abs_value);
16180  *(--buffer_ptr) = digits_to_99[digits_index][1];
16181  *(--buffer_ptr) = digits_to_99[digits_index][0];
16182  }
16183  else
16184  {
16185  *(--buffer_ptr) = static_cast<char>('0' + abs_value);
16186  }
16187 
16188  o->write_characters(number_buffer.data(), n_chars);
16189  }
16190 
16191  /*!
16192  @brief dump a floating-point number
16193 
16194  Dump a given floating-point number to output stream @a o. Works internally
16195  with @a number_buffer.
16196 
16197  @param[in] x floating-point number to dump
16198  */
16199  void dump_float(number_float_t x)
16200  {
16201  // NaN / inf
16202  if (!std::isfinite(x))
16203  {
16204  o->write_characters("null", 4);
16205  return;
16206  }
16207 
16208  // If number_float_t is an IEEE-754 single or double precision number,
16209  // use the Grisu2 algorithm to produce short numbers which are
16210  // guaranteed to round-trip, using strtof and strtod, resp.
16211  //
16212  // NB: The test below works if <long double> == <double>.
16213  static constexpr bool is_ieee_single_or_double
16214  = (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 24 && std::numeric_limits<number_float_t>::max_exponent == 128) ||
16215  (std::numeric_limits<number_float_t>::is_iec559 && std::numeric_limits<number_float_t>::digits == 53 && std::numeric_limits<number_float_t>::max_exponent == 1024);
16216 
16217  dump_float(x, std::integral_constant<bool, is_ieee_single_or_double>());
16218  }
16219 
16220  void dump_float(number_float_t x, std::true_type /*is_ieee_single_or_double*/)
16221  {
16222  char* begin = number_buffer.data();
16223  char* end = ::nlohmann::detail::to_chars(begin, begin + number_buffer.size(), x);
16224 
16225  o->write_characters(begin, static_cast<size_t>(end - begin));
16226  }
16227 
16228  void dump_float(number_float_t x, std::false_type /*is_ieee_single_or_double*/)
16229  {
16230  // get number of digits for a float -> text -> float round-trip
16231  static constexpr auto d = std::numeric_limits<number_float_t>::max_digits10;
16232 
16233  // the actual conversion
16234  std::ptrdiff_t len = (std::snprintf)(number_buffer.data(), number_buffer.size(), "%.*g", d, x);
16235 
16236  // negative value indicates an error
16237  JSON_ASSERT(len > 0);
16238  // check if buffer was large enough
16239  JSON_ASSERT(static_cast<std::size_t>(len) < number_buffer.size());
16240 
16241  // erase thousands separator
16242  if (thousands_sep != '\0')
16243  {
16244  const auto end = std::remove(number_buffer.begin(),
16245  number_buffer.begin() + len, thousands_sep);
16246  std::fill(end, number_buffer.end(), '\0');
16247  JSON_ASSERT((end - number_buffer.begin()) <= len);
16248  len = (end - number_buffer.begin());
16249  }
16250 
16251  // convert decimal point to '.'
16252  if (decimal_point != '\0' && decimal_point != '.')
16253  {
16254  const auto dec_pos = std::find(number_buffer.begin(), number_buffer.end(), decimal_point);
16255  if (dec_pos != number_buffer.end())
16256  {
16257  *dec_pos = '.';
16258  }
16259  }
16260 
16261  o->write_characters(number_buffer.data(), static_cast<std::size_t>(len));
16262 
16263  // determine if need to append ".0"
16264  const bool value_is_int_like =
16265  std::none_of(number_buffer.begin(), number_buffer.begin() + len + 1,
16266  [](char c)
16267  {
16268  return c == '.' || c == 'e';
16269  });
16270 
16271  if (value_is_int_like)
16272  {
16273  o->write_characters(".0", 2);
16274  }
16275  }
16276 
16277  /*!
16278  @brief check whether a string is UTF-8 encoded
16279 
16280  The function checks each byte of a string whether it is UTF-8 encoded. The
16281  result of the check is stored in the @a state parameter. The function must
16282  be called initially with state 0 (accept). State 1 means the string must
16283  be rejected, because the current byte is not allowed. If the string is
16284  completely processed, but the state is non-zero, the string ended
16285  prematurely; that is, the last byte indicated more bytes should have
16286  followed.
16287 
16288  @param[in,out] state the state of the decoding
16289  @param[in,out] codep codepoint (valid only if resulting state is UTF8_ACCEPT)
16290  @param[in] byte next byte to decode
16291  @return new state
16292 
16293  @note The function has been edited: a std::array is used.
16294 
16295  @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
16296  @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
16297  */
16298  static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
16299  {
16300  static const std::array<std::uint8_t, 400> utf8d =
16301  {
16302  {
16303  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
16304  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
16305  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
16306  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
16307  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
16308  7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
16309  8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
16310  0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
16311  0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
16312  0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
16313  1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
16314  1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
16315  1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
16316  1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
16317  }
16318  };
16319 
16320  const std::uint8_t type = utf8d[byte];
16321 
16322  codep = (state != UTF8_ACCEPT)
16323  ? (byte & 0x3fu) | (codep << 6u)
16324  : (0xFFu >> type) & (byte);
16325 
16326  std::size_t index = 256u + static_cast<size_t>(state) * 16u + static_cast<size_t>(type);
16327  JSON_ASSERT(index < 400);
16328  state = utf8d[index];
16329  return state;
16330  }
16331 
16332  /*
16333  * Overload to make the compiler happy while it is instantiating
16334  * dump_integer for number_unsigned_t.
16335  * Must never be called.
16336  */
16337  number_unsigned_t remove_sign(number_unsigned_t x)
16338  {
16339  JSON_ASSERT(false); // LCOV_EXCL_LINE
16340  return x; // LCOV_EXCL_LINE
16341  }
16342 
16343  /*
16344  * Helper function for dump_integer
16345  *
16346  * This function takes a negative signed integer and returns its absolute
16347  * value as unsigned integer. The plus/minus shuffling is necessary as we can
16348  * not directly remove the sign of an arbitrary signed integer as the
16349  * absolute values of INT_MIN and INT_MAX are usually not the same. See
16350  * #1708 for details.
16351  */
16352  inline number_unsigned_t remove_sign(number_integer_t x) noexcept
16353  {
16354  JSON_ASSERT(x < 0 && x < (std::numeric_limits<number_integer_t>::max)());
16355  return static_cast<number_unsigned_t>(-(x + 1)) + 1;
16356  }
16357 
16358  private:
16359  /// the output of the serializer
16361 
16362  /// a (hopefully) large enough character buffer
16363  std::array<char, 64> number_buffer{{}};
16364 
16365  /// the locale
16366  const std::lconv* loc = nullptr;
16367  /// the locale's thousand separator character
16368  const char thousands_sep = '\0';
16369  /// the locale's decimal point character
16370  const char decimal_point = '\0';
16371 
16372  /// string buffer
16373  std::array<char, 512> string_buffer{{}};
16374 
16375  /// the indentation character
16376  const char indent_char;
16377  /// the indentation string
16378  string_t indent_string;
16379 
16380  /// error_handler how to react on decoding errors
16382 };
16383 } // namespace detail
16384 } // namespace nlohmann
16385 
16386 // #include <nlohmann/detail/value_t.hpp>
16387 
16388 // #include <nlohmann/json_fwd.hpp>
16389 
16390 // #include <nlohmann/ordered_map.hpp>
16391 
16392 
16393 #include <functional> // less
16394 #include <memory> // allocator
16395 #include <utility> // pair
16396 #include <vector> // vector
16397 
16398 namespace nlohmann
16399 {
16400 
16401 /// ordered_map: a minimal map-like container that preserves insertion order
16402 /// for use within nlohmann::basic_json<ordered_map>
16403 template <class Key, class T, class IgnoredLess = std::less<Key>,
16404  class Allocator = std::allocator<std::pair<const Key, T>>>
16405  struct ordered_map : std::vector<std::pair<const Key, T>, Allocator>
16406 {
16407  using key_type = Key;
16408  using mapped_type = T;
16409  using Container = std::vector<std::pair<const Key, T>, Allocator>;
16410  using typename Container::iterator;
16411  using typename Container::const_iterator;
16412  using typename Container::size_type;
16413  using typename Container::value_type;
16414 
16415  // Explicit constructors instead of `using Container::Container`
16416  // otherwise older compilers choke on it (GCC <= 5.5, xcode <= 9.4)
16417  ordered_map(const Allocator& alloc = Allocator()) : Container{alloc} {}
16418  template <class It>
16419  ordered_map(It first, It last, const Allocator& alloc = Allocator())
16420  : Container{first, last, alloc} {}
16421  ordered_map(std::initializer_list<T> init, const Allocator& alloc = Allocator() )
16422  : Container{init, alloc} {}
16423 
16424  std::pair<iterator, bool> emplace(const key_type& key, T&& t)
16425  {
16426  for (auto it = this->begin(); it != this->end(); ++it)
16427  {
16428  if (it->first == key)
16429  {
16430  return {it, false};
16431  }
16432  }
16433  Container::emplace_back(key, t);
16434  return {--this->end(), true};
16435  }
16436 
16437  T& operator[](const Key& key)
16438  {
16439  return emplace(key, T{}).first->second;
16440  }
16441 
16442  const T& operator[](const Key& key) const
16443  {
16444  return at(key);
16445  }
16446 
16447  T& at(const Key& key)
16448  {
16449  for (auto it = this->begin(); it != this->end(); ++it)
16450  {
16451  if (it->first == key)
16452  {
16453  return it->second;
16454  }
16455  }
16456 
16457  throw std::out_of_range("key not found");
16458  }
16459 
16460  const T& at(const Key& key) const
16461  {
16462  for (auto it = this->begin(); it != this->end(); ++it)
16463  {
16464  if (it->first == key)
16465  {
16466  return it->second;
16467  }
16468  }
16469 
16470  throw std::out_of_range("key not found");
16471  }
16472 
16473  size_type erase(const Key& key)
16474  {
16475  for (auto it = this->begin(); it != this->end(); ++it)
16476  {
16477  if (it->first == key)
16478  {
16479  // Since we cannot move const Keys, re-construct them in place
16480  for (auto next = it; ++next != this->end(); ++it)
16481  {
16482  it->~value_type(); // Destroy but keep allocation
16483  new (&*it) value_type{std::move(*next)};
16484  }
16485  Container::pop_back();
16486  return 1;
16487  }
16488  }
16489  return 0;
16490  }
16491 
16492  iterator erase(iterator pos)
16493  {
16494  auto it = pos;
16495 
16496  // Since we cannot move const Keys, re-construct them in place
16497  for (auto next = it; ++next != this->end(); ++it)
16498  {
16499  it->~value_type(); // Destroy but keep allocation
16500  new (&*it) value_type{std::move(*next)};
16501  }
16502  Container::pop_back();
16503  return pos;
16504  }
16505 
16506  size_type count(const Key& key) const
16507  {
16508  for (auto it = this->begin(); it != this->end(); ++it)
16509  {
16510  if (it->first == key)
16511  {
16512  return 1;
16513  }
16514  }
16515  return 0;
16516  }
16517 
16518  iterator find(const Key& key)
16519  {
16520  for (auto it = this->begin(); it != this->end(); ++it)
16521  {
16522  if (it->first == key)
16523  {
16524  return it;
16525  }
16526  }
16527  return Container::end();
16528  }
16529 
16530  const_iterator find(const Key& key) const
16531  {
16532  for (auto it = this->begin(); it != this->end(); ++it)
16533  {
16534  if (it->first == key)
16535  {
16536  return it;
16537  }
16538  }
16539  return Container::end();
16540  }
16541 
16542  std::pair<iterator, bool> insert( value_type&& value )
16543  {
16544  return emplace(value.first, std::move(value.second));
16545  }
16546 
16547  std::pair<iterator, bool> insert( const value_type& value )
16548  {
16549  for (auto it = this->begin(); it != this->end(); ++it)
16550  {
16551  if (it->first == value.first)
16552  {
16553  return {it, false};
16554  }
16555  }
16556  Container::push_back(value);
16557  return {--this->end(), true};
16558  }
16559 };
16560 
16561 } // namespace nlohmann
16562 
16563 
16564 /*!
16565 @brief namespace for Niels Lohmann
16566 @see https://github.com/nlohmann
16567 @since version 1.0.0
16568 */
16569 namespace nlohmann
16570 {
16571 
16572 /*!
16573 @brief a class to store JSON values
16574 
16575 @tparam ObjectType type for JSON objects (`std::map` by default; will be used
16576 in @ref object_t)
16577 @tparam ArrayType type for JSON arrays (`std::vector` by default; will be used
16578 in @ref array_t)
16579 @tparam StringType type for JSON strings and object keys (`std::string` by
16580 default; will be used in @ref string_t)
16581 @tparam BooleanType type for JSON booleans (`bool` by default; will be used
16582 in @ref boolean_t)
16583 @tparam NumberIntegerType type for JSON integer numbers (`int64_t` by
16584 default; will be used in @ref number_integer_t)
16585 @tparam NumberUnsignedType type for JSON unsigned integer numbers (@c
16586 `uint64_t` by default; will be used in @ref number_unsigned_t)
16587 @tparam NumberFloatType type for JSON floating-point numbers (`double` by
16588 default; will be used in @ref number_float_t)
16589 @tparam BinaryType type for packed binary data for compatibility with binary
16590 serialization formats (`std::vector<std::uint8_t>` by default; will be used in
16591 @ref binary_t)
16592 @tparam AllocatorType type of the allocator to use (`std::allocator` by
16593 default)
16594 @tparam JSONSerializer the serializer to resolve internal calls to `to_json()`
16595 and `from_json()` (@ref adl_serializer by default)
16596 
16597 @requirement The class satisfies the following concept requirements:
16598 - Basic
16599  - [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible):
16600  JSON values can be default constructed. The result will be a JSON null
16601  value.
16602  - [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible):
16603  A JSON value can be constructed from an rvalue argument.
16604  - [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible):
16605  A JSON value can be copy-constructed from an lvalue expression.
16606  - [MoveAssignable](https://en.cppreference.com/w/cpp/named_req/MoveAssignable):
16607  A JSON value van be assigned from an rvalue argument.
16608  - [CopyAssignable](https://en.cppreference.com/w/cpp/named_req/CopyAssignable):
16609  A JSON value can be copy-assigned from an lvalue expression.
16610  - [Destructible](https://en.cppreference.com/w/cpp/named_req/Destructible):
16611  JSON values can be destructed.
16612 - Layout
16613  - [StandardLayoutType](https://en.cppreference.com/w/cpp/named_req/StandardLayoutType):
16614  JSON values have
16615  [standard layout](https://en.cppreference.com/w/cpp/language/data_members#Standard_layout):
16616  All non-static data members are private and standard layout types, the
16617  class has no virtual functions or (virtual) base classes.
16618 - Library-wide
16619  - [EqualityComparable](https://en.cppreference.com/w/cpp/named_req/EqualityComparable):
16620  JSON values can be compared with `==`, see @ref
16621  operator==(const_reference,const_reference).
16622  - [LessThanComparable](https://en.cppreference.com/w/cpp/named_req/LessThanComparable):
16623  JSON values can be compared with `<`, see @ref
16624  operator<(const_reference,const_reference).
16625  - [Swappable](https://en.cppreference.com/w/cpp/named_req/Swappable):
16626  Any JSON lvalue or rvalue of can be swapped with any lvalue or rvalue of
16627  other compatible types, using unqualified function call @ref swap().
16628  - [NullablePointer](https://en.cppreference.com/w/cpp/named_req/NullablePointer):
16629  JSON values can be compared against `std::nullptr_t` objects which are used
16630  to model the `null` value.
16631 - Container
16632  - [Container](https://en.cppreference.com/w/cpp/named_req/Container):
16633  JSON values can be used like STL containers and provide iterator access.
16634  - [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer);
16635  JSON values can be used like STL containers and provide reverse iterator
16636  access.
16637 
16638 @invariant The member variables @a m_value and @a m_type have the following
16639 relationship:
16640 - If `m_type == value_t::object`, then `m_value.object != nullptr`.
16641 - If `m_type == value_t::array`, then `m_value.array != nullptr`.
16642 - If `m_type == value_t::string`, then `m_value.string != nullptr`.
16643 The invariants are checked by member function assert_invariant().
16644 
16645 @internal
16646 @note ObjectType trick from https://stackoverflow.com/a/9860911
16647 @endinternal
16648 
16649 @see [RFC 7159: The JavaScript Object Notation (JSON) Data Interchange
16650 Format](http://rfc7159.net/rfc7159)
16651 
16652 @since version 1.0.0
16653 
16654 @nosubgrouping
16655 */
16656 NLOHMANN_BASIC_JSON_TPL_DECLARATION
16658 {
16659  private:
16660  template<detail::value_t> friend struct detail::external_constructor;
16661  friend ::nlohmann::json_pointer<basic_json>;
16662 
16663  template<typename BasicJsonType, typename InputType>
16664  friend class ::nlohmann::detail::parser;
16665  friend ::nlohmann::detail::serializer<basic_json>;
16666  template<typename BasicJsonType>
16667  friend class ::nlohmann::detail::iter_impl;
16668  template<typename BasicJsonType, typename CharType>
16669  friend class ::nlohmann::detail::binary_writer;
16670  template<typename BasicJsonType, typename InputType, typename SAX>
16671  friend class ::nlohmann::detail::binary_reader;
16672  template<typename BasicJsonType>
16673  friend class ::nlohmann::detail::json_sax_dom_parser;
16674  template<typename BasicJsonType>
16675  friend class ::nlohmann::detail::json_sax_dom_callback_parser;
16676 
16677  /// workaround type for MSVC
16678  using basic_json_t = NLOHMANN_BASIC_JSON_TPL;
16679 
16680  // convenience aliases for types residing in namespace detail;
16682 
16683  template<typename InputAdapterType>
16684  static ::nlohmann::detail::parser<basic_json, InputAdapterType> parser(
16685  InputAdapterType adapter,
16686  detail::parser_callback_t<basic_json>cb = nullptr,
16687  const bool allow_exceptions = true,
16688  const bool ignore_comments = false
16689  )
16690  {
16691  return ::nlohmann::detail::parser<basic_json, InputAdapterType>(std::move(adapter),
16692  std::move(cb), allow_exceptions, ignore_comments);
16693  }
16694 
16695  using primitive_iterator_t = ::nlohmann::detail::primitive_iterator_t;
16696  template<typename BasicJsonType>
16697  using internal_iterator = ::nlohmann::detail::internal_iterator<BasicJsonType>;
16698  template<typename BasicJsonType>
16700  template<typename Iterator>
16701  using iteration_proxy = ::nlohmann::detail::iteration_proxy<Iterator>;
16702  template<typename Base> using json_reverse_iterator = ::nlohmann::detail::json_reverse_iterator<Base>;
16703 
16704  template<typename CharType>
16705  using output_adapter_t = ::nlohmann::detail::output_adapter_t<CharType>;
16706 
16707  template<typename InputType>
16709  template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
16710 
16711  using serializer = ::nlohmann::detail::serializer<basic_json>;
16712 
16713  public:
16714  using value_t = detail::value_t;
16715  /// JSON Pointer, see @ref nlohmann::json_pointer
16717  template<typename T, typename SFINAE>
16718  using json_serializer = JSONSerializer<T, SFINAE>;
16719  /// how to treat decoding errors
16721  /// how to treat CBOR tags
16723  /// helper type for initializer lists of basic_json values
16724  using initializer_list_t = std::initializer_list<detail::json_ref<basic_json>>;
16725 
16727  /// SAX interface type, see @ref nlohmann::json_sax
16729 
16730  ////////////////
16731  // exceptions //
16732  ////////////////
16733 
16734  /// @name exceptions
16735  /// Classes to implement user-defined exceptions.
16736  /// @{
16737 
16738  /// @copydoc detail::exception
16740  /// @copydoc detail::parse_error
16742  /// @copydoc detail::invalid_iterator
16744  /// @copydoc detail::type_error
16746  /// @copydoc detail::out_of_range
16748  /// @copydoc detail::other_error
16750 
16751  /// @}
16752 
16753 
16754  /////////////////////
16755  // container types //
16756  /////////////////////
16757 
16758  /// @name container types
16759  /// The canonic container types to use @ref basic_json like any other STL
16760  /// container.
16761  /// @{
16762 
16763  /// the type of elements in a basic_json container
16765 
16766  /// the type of an element reference
16768  /// the type of an element const reference
16769  using const_reference = const value_type&;
16770 
16771  /// a type to represent differences between iterators
16772  using difference_type = std::ptrdiff_t;
16773  /// a type to represent container sizes
16774  using size_type = std::size_t;
16775 
16776  /// the allocator type
16777  using allocator_type = AllocatorType<basic_json>;
16778 
16779  /// the type of an element pointer
16780  using pointer = typename std::allocator_traits<allocator_type>::pointer;
16781  /// the type of an element const pointer
16782  using const_pointer = typename std::allocator_traits<allocator_type>::const_pointer;
16783 
16784  /// an iterator for a basic_json container
16786  /// a const iterator for a basic_json container
16788  /// a reverse iterator for a basic_json container
16790  /// a const reverse iterator for a basic_json container
16792 
16793  /// @}
16794 
16795 
16796  /*!
16797  @brief returns the allocator associated with the container
16798  */
16800  {
16801  return allocator_type();
16802  }
16803 
16804  /*!
16805  @brief returns version information on the library
16806 
16807  This function returns a JSON object with information about the library,
16808  including the version number and information on the platform and compiler.
16809 
16810  @return JSON object holding version information
16811  key | description
16812  ----------- | ---------------
16813  `compiler` | Information on the used compiler. It is an object with the following keys: `c++` (the used C++ standard), `family` (the compiler family; possible values are `clang`, `icc`, `gcc`, `ilecpp`, `msvc`, `pgcpp`, `sunpro`, and `unknown`), and `version` (the compiler version).
16814  `copyright` | The copyright line for the library as string.
16815  `name` | The name of the library as string.
16816  `platform` | The used platform as string. Possible values are `win32`, `linux`, `apple`, `unix`, and `unknown`.
16817  `url` | The URL of the project as string.
16818  `version` | The version of the library. It is an object with the following keys: `major`, `minor`, and `patch` as defined by [Semantic Versioning](http://semver.org), and `string` (the version string).
16819 
16820  @liveexample{The following code shows an example output of the `meta()`
16821  function.,meta}
16822 
16823  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
16824  changes to any JSON value.
16825 
16826  @complexity Constant.
16827 
16828  @since 2.1.0
16829  */
16830  JSON_HEDLEY_WARN_UNUSED_RESULT
16831  static basic_json meta()
16832  {
16833  basic_json result;
16834 
16835  result["copyright"] = "(C) 2013-2020 Niels Lohmann";
16836  result["name"] = "JSON for Modern C++";
16837  result["url"] = "https://github.com/nlohmann/json";
16838  result["version"]["string"] =
16839  std::to_string(NLOHMANN_JSON_VERSION_MAJOR) + "." +
16840  std::to_string(NLOHMANN_JSON_VERSION_MINOR) + "." +
16841  std::to_string(NLOHMANN_JSON_VERSION_PATCH);
16842  result["version"]["major"] = NLOHMANN_JSON_VERSION_MAJOR;
16843  result["version"]["minor"] = NLOHMANN_JSON_VERSION_MINOR;
16844  result["version"]["patch"] = NLOHMANN_JSON_VERSION_PATCH;
16845 
16846 #ifdef _WIN32
16847  result["platform"] = "win32";
16848 #elif defined __linux__
16849  result["platform"] = "linux";
16850 #elif defined __APPLE__
16851  result["platform"] = "apple";
16852 #elif defined __unix__
16853  result["platform"] = "unix";
16854 #else
16855  result["platform"] = "unknown";
16856 #endif
16857 
16858 #if defined(__ICC) || defined(__INTEL_COMPILER)
16859  result["compiler"] = {{"family", "icc"}, {"version", __INTEL_COMPILER}};
16860 #elif defined(__clang__)
16861  result["compiler"] = {{"family", "clang"}, {"version", __clang_version__}};
16862 #elif defined(__GNUC__) || defined(__GNUG__)
16863  result["compiler"] = {{"family", "gcc"}, {"version", std::to_string(__GNUC__) + "." + std::to_string(__GNUC_MINOR__) + "." + std::to_string(__GNUC_PATCHLEVEL__)}};
16864 #elif defined(__HP_cc) || defined(__HP_aCC)
16865  result["compiler"] = "hp"
16866 #elif defined(__IBMCPP__)
16867  result["compiler"] = {{"family", "ilecpp"}, {"version", __IBMCPP__}};
16868 #elif defined(_MSC_VER)
16869  result["compiler"] = {{"family", "msvc"}, {"version", _MSC_VER}};
16870 #elif defined(__PGI)
16871  result["compiler"] = {{"family", "pgcpp"}, {"version", __PGI}};
16872 #elif defined(__SUNPRO_CC)
16873  result["compiler"] = {{"family", "sunpro"}, {"version", __SUNPRO_CC}};
16874 #else
16875  result["compiler"] = {{"family", "unknown"}, {"version", "unknown"}};
16876 #endif
16877 
16878 #ifdef __cplusplus
16879  result["compiler"]["c++"] = std::to_string(__cplusplus);
16880 #else
16881  result["compiler"]["c++"] = "unknown";
16882 #endif
16883  return result;
16884  }
16885 
16886 
16887  ///////////////////////////
16888  // JSON value data types //
16889  ///////////////////////////
16890 
16891  /// @name JSON value data types
16892  /// The data types to store a JSON value. These types are derived from
16893  /// the template arguments passed to class @ref basic_json.
16894  /// @{
16895 
16896 #if defined(JSON_HAS_CPP_14)
16897  // Use transparent comparator if possible, combined with perfect forwarding
16898  // on find() and count() calls prevents unnecessary string construction.
16899  using object_comparator_t = std::less<>;
16900 #else
16901  using object_comparator_t = std::less<StringType>;
16902 #endif
16903 
16904  /*!
16905  @brief a type for an object
16906 
16907  [RFC 7159](http://rfc7159.net/rfc7159) describes JSON objects as follows:
16908  > An object is an unordered collection of zero or more name/value pairs,
16909  > where a name is a string and a value is a string, number, boolean, null,
16910  > object, or array.
16911 
16912  To store objects in C++, a type is defined by the template parameters
16913  described below.
16914 
16915  @tparam ObjectType the container to store objects (e.g., `std::map` or
16916  `std::unordered_map`)
16917  @tparam StringType the type of the keys or names (e.g., `std::string`).
16918  The comparison function `std::less<StringType>` is used to order elements
16919  inside the container.
16920  @tparam AllocatorType the allocator to use for objects (e.g.,
16921  `std::allocator`)
16922 
16923  #### Default type
16924 
16925  With the default values for @a ObjectType (`std::map`), @a StringType
16926  (`std::string`), and @a AllocatorType (`std::allocator`), the default
16927  value for @a object_t is:
16928 
16929  @code {.cpp}
16930  std::map<
16931  std::string, // key_type
16932  basic_json, // value_type
16933  std::less<std::string>, // key_compare
16934  std::allocator<std::pair<const std::string, basic_json>> // allocator_type
16935  >
16936  @endcode
16937 
16938  #### Behavior
16939 
16940  The choice of @a object_t influences the behavior of the JSON class. With
16941  the default type, objects have the following behavior:
16942 
16943  - When all names are unique, objects will be interoperable in the sense
16944  that all software implementations receiving that object will agree on
16945  the name-value mappings.
16946  - When the names within an object are not unique, it is unspecified which
16947  one of the values for a given key will be chosen. For instance,
16948  `{"key": 2, "key": 1}` could be equal to either `{"key": 1}` or
16949  `{"key": 2}`.
16950  - Internally, name/value pairs are stored in lexicographical order of the
16951  names. Objects will also be serialized (see @ref dump) in this order.
16952  For instance, `{"b": 1, "a": 2}` and `{"a": 2, "b": 1}` will be stored
16953  and serialized as `{"a": 2, "b": 1}`.
16954  - When comparing objects, the order of the name/value pairs is irrelevant.
16955  This makes objects interoperable in the sense that they will not be
16956  affected by these differences. For instance, `{"b": 1, "a": 2}` and
16957  `{"a": 2, "b": 1}` will be treated as equal.
16958 
16959  #### Limits
16960 
16961  [RFC 7159](http://rfc7159.net/rfc7159) specifies:
16962  > An implementation may set limits on the maximum depth of nesting.
16963 
16964  In this class, the object's limit of nesting is not explicitly constrained.
16965  However, a maximum depth of nesting may be introduced by the compiler or
16966  runtime environment. A theoretical limit can be queried by calling the
16967  @ref max_size function of a JSON object.
16968 
16969  #### Storage
16970 
16971  Objects are stored as pointers in a @ref basic_json type. That is, for any
16972  access to object values, a pointer of type `object_t*` must be
16973  dereferenced.
16974 
16975  @sa @ref array_t -- type for an array value
16976 
16977  @since version 1.0.0
16978 
16979  @note The order name/value pairs are added to the object is *not*
16980  preserved by the library. Therefore, iterating an object may return
16981  name/value pairs in a different order than they were originally stored. In
16982  fact, keys will be traversed in alphabetical order as `std::map` with
16983  `std::less` is used by default. Please note this behavior conforms to [RFC
16984  7159](http://rfc7159.net/rfc7159), because any order implements the
16985  specified "unordered" nature of JSON objects.
16986  */
16987  using object_t = ObjectType<StringType,
16988  basic_json,
16989  object_comparator_t,
16990  AllocatorType<std::pair<const StringType,
16991  basic_json>>>;
16992 
16993  /*!
16994  @brief a type for an array
16995 
16996  [RFC 7159](http://rfc7159.net/rfc7159) describes JSON arrays as follows:
16997  > An array is an ordered sequence of zero or more values.
16998 
16999  To store objects in C++, a type is defined by the template parameters
17000  explained below.
17001 
17002  @tparam ArrayType container type to store arrays (e.g., `std::vector` or
17003  `std::list`)
17004  @tparam AllocatorType allocator to use for arrays (e.g., `std::allocator`)
17005 
17006  #### Default type
17007 
17008  With the default values for @a ArrayType (`std::vector`) and @a
17009  AllocatorType (`std::allocator`), the default value for @a array_t is:
17010 
17011  @code {.cpp}
17012  std::vector<
17013  basic_json, // value_type
17014  std::allocator<basic_json> // allocator_type
17015  >
17016  @endcode
17017 
17018  #### Limits
17019 
17020  [RFC 7159](http://rfc7159.net/rfc7159) specifies:
17021  > An implementation may set limits on the maximum depth of nesting.
17022 
17023  In this class, the array's limit of nesting is not explicitly constrained.
17024  However, a maximum depth of nesting may be introduced by the compiler or
17025  runtime environment. A theoretical limit can be queried by calling the
17026  @ref max_size function of a JSON array.
17027 
17028  #### Storage
17029 
17030  Arrays are stored as pointers in a @ref basic_json type. That is, for any
17031  access to array values, a pointer of type `array_t*` must be dereferenced.
17032 
17033  @sa @ref object_t -- type for an object value
17034 
17035  @since version 1.0.0
17036  */
17037  using array_t = ArrayType<basic_json, AllocatorType<basic_json>>;
17038 
17039  /*!
17040  @brief a type for a string
17041 
17042  [RFC 7159](http://rfc7159.net/rfc7159) describes JSON strings as follows:
17043  > A string is a sequence of zero or more Unicode characters.
17044 
17045  To store objects in C++, a type is defined by the template parameter
17046  described below. Unicode values are split by the JSON class into
17047  byte-sized characters during deserialization.
17048 
17049  @tparam StringType the container to store strings (e.g., `std::string`).
17050  Note this container is used for keys/names in objects, see @ref object_t.
17051 
17052  #### Default type
17053 
17054  With the default values for @a StringType (`std::string`), the default
17055  value for @a string_t is:
17056 
17057  @code {.cpp}
17058  std::string
17059  @endcode
17060 
17061  #### Encoding
17062 
17063  Strings are stored in UTF-8 encoding. Therefore, functions like
17064  `std::string::size()` or `std::string::length()` return the number of
17065  bytes in the string rather than the number of characters or glyphs.
17066 
17067  #### String comparison
17068 
17069  [RFC 7159](http://rfc7159.net/rfc7159) states:
17070  > Software implementations are typically required to test names of object
17071  > members for equality. Implementations that transform the textual
17072  > representation into sequences of Unicode code units and then perform the
17073  > comparison numerically, code unit by code unit, are interoperable in the
17074  > sense that implementations will agree in all cases on equality or
17075  > inequality of two strings. For example, implementations that compare
17076  > strings with escaped characters unconverted may incorrectly find that
17077  > `"a\\b"` and `"a\u005Cb"` are not equal.
17078 
17079  This implementation is interoperable as it does compare strings code unit
17080  by code unit.
17081 
17082  #### Storage
17083 
17084  String values are stored as pointers in a @ref basic_json type. That is,
17085  for any access to string values, a pointer of type `string_t*` must be
17086  dereferenced.
17087 
17088  @since version 1.0.0
17089  */
17090  using string_t = StringType;
17091 
17092  /*!
17093  @brief a type for a boolean
17094 
17095  [RFC 7159](http://rfc7159.net/rfc7159) implicitly describes a boolean as a
17096  type which differentiates the two literals `true` and `false`.
17097 
17098  To store objects in C++, a type is defined by the template parameter @a
17099  BooleanType which chooses the type to use.
17100 
17101  #### Default type
17102 
17103  With the default values for @a BooleanType (`bool`), the default value for
17104  @a boolean_t is:
17105 
17106  @code {.cpp}
17107  bool
17108  @endcode
17109 
17110  #### Storage
17111 
17112  Boolean values are stored directly inside a @ref basic_json type.
17113 
17114  @since version 1.0.0
17115  */
17116  using boolean_t = BooleanType;
17117 
17118  /*!
17119  @brief a type for a number (integer)
17120 
17121  [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
17122  > The representation of numbers is similar to that used in most
17123  > programming languages. A number is represented in base 10 using decimal
17124  > digits. It contains an integer component that may be prefixed with an
17125  > optional minus sign, which may be followed by a fraction part and/or an
17126  > exponent part. Leading zeros are not allowed. (...) Numeric values that
17127  > cannot be represented in the grammar below (such as Infinity and NaN)
17128  > are not permitted.
17129 
17130  This description includes both integer and floating-point numbers.
17131  However, C++ allows more precise storage if it is known whether the number
17132  is a signed integer, an unsigned integer or a floating-point number.
17133  Therefore, three different types, @ref number_integer_t, @ref
17134  number_unsigned_t and @ref number_float_t are used.
17135 
17136  To store integer numbers in C++, a type is defined by the template
17137  parameter @a NumberIntegerType which chooses the type to use.
17138 
17139  #### Default type
17140 
17141  With the default values for @a NumberIntegerType (`int64_t`), the default
17142  value for @a number_integer_t is:
17143 
17144  @code {.cpp}
17145  int64_t
17146  @endcode
17147 
17148  #### Default behavior
17149 
17150  - The restrictions about leading zeros is not enforced in C++. Instead,
17151  leading zeros in integer literals lead to an interpretation as octal
17152  number. Internally, the value will be stored as decimal number. For
17153  instance, the C++ integer literal `010` will be serialized to `8`.
17154  During deserialization, leading zeros yield an error.
17155  - Not-a-number (NaN) values will be serialized to `null`.
17156 
17157  #### Limits
17158 
17159  [RFC 7159](http://rfc7159.net/rfc7159) specifies:
17160  > An implementation may set limits on the range and precision of numbers.
17161 
17162  When the default type is used, the maximal integer number that can be
17163  stored is `9223372036854775807` (INT64_MAX) and the minimal integer number
17164  that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers
17165  that are out of range will yield over/underflow when used in a
17166  constructor. During deserialization, too large or small integer numbers
17167  will be automatically be stored as @ref number_unsigned_t or @ref
17168  number_float_t.
17169 
17170  [RFC 7159](http://rfc7159.net/rfc7159) further states:
17171  > Note that when such software is used, numbers that are integers and are
17172  > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
17173  > that implementations will agree exactly on their numeric values.
17174 
17175  As this range is a subrange of the exactly supported range [INT64_MIN,
17176  INT64_MAX], this class's integer type is interoperable.
17177 
17178  #### Storage
17179 
17180  Integer number values are stored directly inside a @ref basic_json type.
17181 
17182  @sa @ref number_float_t -- type for number values (floating-point)
17183 
17184  @sa @ref number_unsigned_t -- type for number values (unsigned integer)
17185 
17186  @since version 1.0.0
17187  */
17188  using number_integer_t = NumberIntegerType;
17189 
17190  /*!
17191  @brief a type for a number (unsigned)
17192 
17193  [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
17194  > The representation of numbers is similar to that used in most
17195  > programming languages. A number is represented in base 10 using decimal
17196  > digits. It contains an integer component that may be prefixed with an
17197  > optional minus sign, which may be followed by a fraction part and/or an
17198  > exponent part. Leading zeros are not allowed. (...) Numeric values that
17199  > cannot be represented in the grammar below (such as Infinity and NaN)
17200  > are not permitted.
17201 
17202  This description includes both integer and floating-point numbers.
17203  However, C++ allows more precise storage if it is known whether the number
17204  is a signed integer, an unsigned integer or a floating-point number.
17205  Therefore, three different types, @ref number_integer_t, @ref
17206  number_unsigned_t and @ref number_float_t are used.
17207 
17208  To store unsigned integer numbers in C++, a type is defined by the
17209  template parameter @a NumberUnsignedType which chooses the type to use.
17210 
17211  #### Default type
17212 
17213  With the default values for @a NumberUnsignedType (`uint64_t`), the
17214  default value for @a number_unsigned_t is:
17215 
17216  @code {.cpp}
17217  uint64_t
17218  @endcode
17219 
17220  #### Default behavior
17221 
17222  - The restrictions about leading zeros is not enforced in C++. Instead,
17223  leading zeros in integer literals lead to an interpretation as octal
17224  number. Internally, the value will be stored as decimal number. For
17225  instance, the C++ integer literal `010` will be serialized to `8`.
17226  During deserialization, leading zeros yield an error.
17227  - Not-a-number (NaN) values will be serialized to `null`.
17228 
17229  #### Limits
17230 
17231  [RFC 7159](http://rfc7159.net/rfc7159) specifies:
17232  > An implementation may set limits on the range and precision of numbers.
17233 
17234  When the default type is used, the maximal integer number that can be
17235  stored is `18446744073709551615` (UINT64_MAX) and the minimal integer
17236  number that can be stored is `0`. Integer numbers that are out of range
17237  will yield over/underflow when used in a constructor. During
17238  deserialization, too large or small integer numbers will be automatically
17239  be stored as @ref number_integer_t or @ref number_float_t.
17240 
17241  [RFC 7159](http://rfc7159.net/rfc7159) further states:
17242  > Note that when such software is used, numbers that are integers and are
17243  > in the range \f$[-2^{53}+1, 2^{53}-1]\f$ are interoperable in the sense
17244  > that implementations will agree exactly on their numeric values.
17245 
17246  As this range is a subrange (when considered in conjunction with the
17247  number_integer_t type) of the exactly supported range [0, UINT64_MAX],
17248  this class's integer type is interoperable.
17249 
17250  #### Storage
17251 
17252  Integer number values are stored directly inside a @ref basic_json type.
17253 
17254  @sa @ref number_float_t -- type for number values (floating-point)
17255  @sa @ref number_integer_t -- type for number values (integer)
17256 
17257  @since version 2.0.0
17258  */
17259  using number_unsigned_t = NumberUnsignedType;
17260 
17261  /*!
17262  @brief a type for a number (floating-point)
17263 
17264  [RFC 7159](http://rfc7159.net/rfc7159) describes numbers as follows:
17265  > The representation of numbers is similar to that used in most
17266  > programming languages. A number is represented in base 10 using decimal
17267  > digits. It contains an integer component that may be prefixed with an
17268  > optional minus sign, which may be followed by a fraction part and/or an
17269  > exponent part. Leading zeros are not allowed. (...) Numeric values that
17270  > cannot be represented in the grammar below (such as Infinity and NaN)
17271  > are not permitted.
17272 
17273  This description includes both integer and floating-point numbers.
17274  However, C++ allows more precise storage if it is known whether the number
17275  is a signed integer, an unsigned integer or a floating-point number.
17276  Therefore, three different types, @ref number_integer_t, @ref
17277  number_unsigned_t and @ref number_float_t are used.
17278 
17279  To store floating-point numbers in C++, a type is defined by the template
17280  parameter @a NumberFloatType which chooses the type to use.
17281 
17282  #### Default type
17283 
17284  With the default values for @a NumberFloatType (`double`), the default
17285  value for @a number_float_t is:
17286 
17287  @code {.cpp}
17288  double
17289  @endcode
17290 
17291  #### Default behavior
17292 
17293  - The restrictions about leading zeros is not enforced in C++. Instead,
17294  leading zeros in floating-point literals will be ignored. Internally,
17295  the value will be stored as decimal number. For instance, the C++
17296  floating-point literal `01.2` will be serialized to `1.2`. During
17297  deserialization, leading zeros yield an error.
17298  - Not-a-number (NaN) values will be serialized to `null`.
17299 
17300  #### Limits
17301 
17302  [RFC 7159](http://rfc7159.net/rfc7159) states:
17303  > This specification allows implementations to set limits on the range and
17304  > precision of numbers accepted. Since software that implements IEEE
17305  > 754-2008 binary64 (double precision) numbers is generally available and
17306  > widely used, good interoperability can be achieved by implementations
17307  > that expect no more precision or range than these provide, in the sense
17308  > that implementations will approximate JSON numbers within the expected
17309  > precision.
17310 
17311  This implementation does exactly follow this approach, as it uses double
17312  precision floating-point numbers. Note values smaller than
17313  `-1.79769313486232e+308` and values greater than `1.79769313486232e+308`
17314  will be stored as NaN internally and be serialized to `null`.
17315 
17316  #### Storage
17317 
17318  Floating-point number values are stored directly inside a @ref basic_json
17319  type.
17320 
17321  @sa @ref number_integer_t -- type for number values (integer)
17322 
17323  @sa @ref number_unsigned_t -- type for number values (unsigned integer)
17324 
17325  @since version 1.0.0
17326  */
17327  using number_float_t = NumberFloatType;
17328 
17329  /*!
17330  @brief a type for a packed binary type
17331 
17332  This type is a type designed to carry binary data that appears in various
17333  serialized formats, such as CBOR's Major Type 2, MessagePack's bin, and
17334  BSON's generic binary subtype. This type is NOT a part of standard JSON and
17335  exists solely for compatibility with these binary types. As such, it is
17336  simply defined as an ordered sequence of zero or more byte values.
17337 
17338  Additionally, as an implementation detail, the subtype of the binary data is
17339  carried around as a `std::uint8_t`, which is compatible with both of the
17340  binary data formats that use binary subtyping, (though the specific
17341  numbering is incompatible with each other, and it is up to the user to
17342  translate between them).
17343 
17344  [CBOR's RFC 7049](https://tools.ietf.org/html/rfc7049) describes this type
17345  as:
17346  > Major type 2: a byte string. The string's length in bytes is represented
17347  > following the rules for positive integers (major type 0).
17348 
17349  [MessagePack's documentation on the bin type
17350  family](https://github.com/msgpack/msgpack/blob/master/spec.md#bin-format-family)
17351  describes this type as:
17352  > Bin format family stores an byte array in 2, 3, or 5 bytes of extra bytes
17353  > in addition to the size of the byte array.
17354 
17355  [BSON's specifications](http://bsonspec.org/spec.html) describe several
17356  binary types; however, this type is intended to represent the generic binary
17357  type which has the description:
17358  > Generic binary subtype - This is the most commonly used binary subtype and
17359  > should be the 'default' for drivers and tools.
17360 
17361  None of these impose any limitations on the internal representation other
17362  than the basic unit of storage be some type of array whose parts are
17363  decomposable into bytes.
17364 
17365  The default representation of this binary format is a
17366  `std::vector<std::uint8_t>`, which is a very common way to represent a byte
17367  array in modern C++.
17368 
17369  #### Default type
17370 
17371  The default values for @a BinaryType is `std::vector<std::uint8_t>`
17372 
17373  #### Storage
17374 
17375  Binary Arrays are stored as pointers in a @ref basic_json type. That is,
17376  for any access to array values, a pointer of the type `binary_t*` must be
17377  dereferenced.
17378 
17379  #### Notes on subtypes
17380 
17381  - CBOR
17382  - Binary values are represented as byte strings. No subtypes are
17383  supported and will be ignored when CBOR is written.
17384  - MessagePack
17385  - If a subtype is given and the binary array contains exactly 1, 2, 4, 8,
17386  or 16 elements, the fixext family (fixext1, fixext2, fixext4, fixext8)
17387  is used. For other sizes, the ext family (ext8, ext16, ext32) is used.
17388  The subtype is then added as singed 8-bit integer.
17389  - If no subtype is given, the bin family (bin8, bin16, bin32) is used.
17390  - BSON
17391  - If a subtype is given, it is used and added as unsigned 8-bit integer.
17392  - If no subtype is given, the generic binary subtype 0x00 is used.
17393 
17394  @sa @ref binary -- create a binary array
17395 
17396  @since version 3.8.0
17397  */
17399  /// @}
17400 
17401  private:
17402 
17403  /// helper for exception-safe object creation
17404  template<typename T, typename... Args>
17405  JSON_HEDLEY_RETURNS_NON_NULL
17406  static T* create(Args&& ... args)
17407  {
17408  AllocatorType<T> alloc;
17409  using AllocatorTraits = std::allocator_traits<AllocatorType<T>>;
17410 
17411  auto deleter = [&](T * object)
17412  {
17413  AllocatorTraits::deallocate(alloc, object, 1);
17414  };
17415  std::unique_ptr<T, decltype(deleter)> object(AllocatorTraits::allocate(alloc, 1), deleter);
17416  AllocatorTraits::construct(alloc, object.get(), std::forward<Args>(args)...);
17417  JSON_ASSERT(object != nullptr);
17418  return object.release();
17419  }
17420 
17421  ////////////////////////
17422  // JSON value storage //
17423  ////////////////////////
17424 
17425  /*!
17426  @brief a JSON value
17427 
17428  The actual storage for a JSON value of the @ref basic_json class. This
17429  union combines the different storage types for the JSON value types
17430  defined in @ref value_t.
17431 
17432  JSON type | value_t type | used type
17433  --------- | --------------- | ------------------------
17434  object | object | pointer to @ref object_t
17435  array | array | pointer to @ref array_t
17436  string | string | pointer to @ref string_t
17437  boolean | boolean | @ref boolean_t
17438  number | number_integer | @ref number_integer_t
17439  number | number_unsigned | @ref number_unsigned_t
17440  number | number_float | @ref number_float_t
17441  binary | binary | pointer to @ref binary_t
17442  null | null | *no value is stored*
17443 
17444  @note Variable-length types (objects, arrays, and strings) are stored as
17445  pointers. The size of the union should not exceed 64 bits if the default
17446  value types are used.
17447 
17448  @since version 1.0.0
17449  */
17451  {
17452  /// object (stored with pointer to save storage)
17454  /// array (stored with pointer to save storage)
17456  /// string (stored with pointer to save storage)
17458  /// binary (stored with pointer to save storage)
17460  /// boolean
17462  /// number (integer)
17464  /// number (unsigned integer)
17466  /// number (floating-point)
17468 
17469  /// default constructor (for null values)
17470  json_value() = default;
17471  /// constructor for booleans
17472  json_value(boolean_t v) noexcept : boolean(v) {}
17473  /// constructor for numbers (integer)
17475  /// constructor for numbers (unsigned)
17477  /// constructor for numbers (floating-point)
17479  /// constructor for empty values of a given type
17481  {
17482  switch (t)
17483  {
17484  case value_t::object:
17485  {
17486  object = create<object_t>();
17487  break;
17488  }
17489 
17490  case value_t::array:
17491  {
17492  array = create<array_t>();
17493  break;
17494  }
17495 
17496  case value_t::string:
17497  {
17498  string = create<string_t>("");
17499  break;
17500  }
17501 
17502  case value_t::binary:
17503  {
17504  binary = create<binary_t>();
17505  break;
17506  }
17507 
17508  case value_t::boolean:
17509  {
17510  boolean = boolean_t(false);
17511  break;
17512  }
17513 
17515  {
17517  break;
17518  }
17519 
17521  {
17523  break;
17524  }
17525 
17526  case value_t::number_float:
17527  {
17529  break;
17530  }
17531 
17532  case value_t::null:
17533  {
17534  object = nullptr; // silence warning, see #821
17535  break;
17536  }
17537 
17538  default:
17539  {
17540  object = nullptr; // silence warning, see #821
17541  if (JSON_HEDLEY_UNLIKELY(t == value_t::null))
17542  {
17543  JSON_THROW(other_error::create(500, "961c151d2e87f2686a955a9be24d316f1362bf21 3.9.1")); // LCOV_EXCL_LINE
17544  }
17545  break;
17546  }
17547  }
17548  }
17549 
17550  /// constructor for strings
17552  {
17553  string = create<string_t>(value);
17554  }
17555 
17556  /// constructor for rvalue strings
17558  {
17559  string = create<string_t>(std::move(value));
17560  }
17561 
17562  /// constructor for objects
17564  {
17565  object = create<object_t>(value);
17566  }
17567 
17568  /// constructor for rvalue objects
17570  {
17571  object = create<object_t>(std::move(value));
17572  }
17573 
17574  /// constructor for arrays
17576  {
17577  array = create<array_t>(value);
17578  }
17579 
17580  /// constructor for rvalue arrays
17582  {
17583  array = create<array_t>(std::move(value));
17584  }
17585 
17586  /// constructor for binary arrays
17588  {
17589  binary = create<binary_t>(value);
17590  }
17591 
17592  /// constructor for rvalue binary arrays
17594  {
17595  binary = create<binary_t>(std::move(value));
17596  }
17597 
17598  /// constructor for binary arrays (internal type)
17600  {
17601  binary = create<binary_t>(value);
17602  }
17603 
17604  /// constructor for rvalue binary arrays (internal type)
17606  {
17607  binary = create<binary_t>(std::move(value));
17608  }
17609 
17610  void destroy(value_t t) noexcept
17611  {
17612  // flatten the current json_value to a heap-allocated stack
17613  std::vector<basic_json> stack;
17614 
17615  // move the top-level items to stack
17616  if (t == value_t::array)
17617  {
17618  stack.reserve(array->size());
17619  std::move(array->begin(), array->end(), std::back_inserter(stack));
17620  }
17621  else if (t == value_t::object)
17622  {
17623  stack.reserve(object->size());
17624  for (auto&& it : *object)
17625  {
17626  stack.push_back(std::move(it.second));
17627  }
17628  }
17629 
17630  while (!stack.empty())
17631  {
17632  // move the last item to local variable to be processed
17633  basic_json current_item(std::move(stack.back()));
17634  stack.pop_back();
17635 
17636  // if current_item is array/object, move
17637  // its children to the stack to be processed later
17638  if (current_item.is_array())
17639  {
17640  std::move(current_item.m_value.array->begin(), current_item.m_value.array->end(),
17641  std::back_inserter(stack));
17642 
17643  current_item.m_value.array->clear();
17644  }
17645  else if (current_item.is_object())
17646  {
17647  for (auto&& it : *current_item.m_value.object)
17648  {
17649  stack.push_back(std::move(it.second));
17650  }
17651 
17652  current_item.m_value.object->clear();
17653  }
17654 
17655  // it's now safe that current_item get destructed
17656  // since it doesn't have any children
17657  }
17658 
17659  switch (t)
17660  {
17661  case value_t::object:
17662  {
17663  AllocatorType<object_t> alloc;
17664  std::allocator_traits<decltype(alloc)>::destroy(alloc, object);
17665  std::allocator_traits<decltype(alloc)>::deallocate(alloc, object, 1);
17666  break;
17667  }
17668 
17669  case value_t::array:
17670  {
17671  AllocatorType<array_t> alloc;
17672  std::allocator_traits<decltype(alloc)>::destroy(alloc, array);
17673  std::allocator_traits<decltype(alloc)>::deallocate(alloc, array, 1);
17674  break;
17675  }
17676 
17677  case value_t::string:
17678  {
17679  AllocatorType<string_t> alloc;
17680  std::allocator_traits<decltype(alloc)>::destroy(alloc, string);
17681  std::allocator_traits<decltype(alloc)>::deallocate(alloc, string, 1);
17682  break;
17683  }
17684 
17685  case value_t::binary:
17686  {
17687  AllocatorType<binary_t> alloc;
17688  std::allocator_traits<decltype(alloc)>::destroy(alloc, binary);
17689  std::allocator_traits<decltype(alloc)>::deallocate(alloc, binary, 1);
17690  break;
17691  }
17692 
17693  default:
17694  {
17695  break;
17696  }
17697  }
17698  }
17699  };
17700 
17701  /*!
17702  @brief checks the class invariants
17703 
17704  This function asserts the class invariants. It needs to be called at the
17705  end of every constructor to make sure that created objects respect the
17706  invariant. Furthermore, it has to be called each time the type of a JSON
17707  value is changed, because the invariant expresses a relationship between
17708  @a m_type and @a m_value.
17709  */
17710  void assert_invariant() const noexcept
17711  {
17712  JSON_ASSERT(m_type != value_t::object || m_value.object != nullptr);
17713  JSON_ASSERT(m_type != value_t::array || m_value.array != nullptr);
17714  JSON_ASSERT(m_type != value_t::string || m_value.string != nullptr);
17715  JSON_ASSERT(m_type != value_t::binary || m_value.binary != nullptr);
17716  }
17717 
17718  public:
17719  //////////////////////////
17720  // JSON parser callback //
17721  //////////////////////////
17722 
17723  /*!
17724  @brief parser event types
17725 
17726  The parser callback distinguishes the following events:
17727  - `object_start`: the parser read `{` and started to process a JSON object
17728  - `key`: the parser read a key of a value in an object
17729  - `object_end`: the parser read `}` and finished processing a JSON object
17730  - `array_start`: the parser read `[` and started to process a JSON array
17731  - `array_end`: the parser read `]` and finished processing a JSON array
17732  - `value`: the parser finished reading a JSON value
17733 
17734  @image html callback_events.png "Example when certain parse events are triggered"
17735 
17736  @sa @ref parser_callback_t for more information and examples
17737  */
17739 
17740  /*!
17741  @brief per-element parser callback type
17742 
17743  With a parser callback function, the result of parsing a JSON text can be
17744  influenced. When passed to @ref parse, it is called on certain events
17745  (passed as @ref parse_event_t via parameter @a event) with a set recursion
17746  depth @a depth and context JSON value @a parsed. The return value of the
17747  callback function is a boolean indicating whether the element that emitted
17748  the callback shall be kept or not.
17749 
17750  We distinguish six scenarios (determined by the event type) in which the
17751  callback function can be called. The following table describes the values
17752  of the parameters @a depth, @a event, and @a parsed.
17753 
17754  parameter @a event | description | parameter @a depth | parameter @a parsed
17755  ------------------ | ----------- | ------------------ | -------------------
17756  parse_event_t::object_start | the parser read `{` and started to process a JSON object | depth of the parent of the JSON object | a JSON value with type discarded
17757  parse_event_t::key | the parser read a key of a value in an object | depth of the currently parsed JSON object | a JSON string containing the key
17758  parse_event_t::object_end | the parser read `}` and finished processing a JSON object | depth of the parent of the JSON object | the parsed JSON object
17759  parse_event_t::array_start | the parser read `[` and started to process a JSON array | depth of the parent of the JSON array | a JSON value with type discarded
17760  parse_event_t::array_end | the parser read `]` and finished processing a JSON array | depth of the parent of the JSON array | the parsed JSON array
17761  parse_event_t::value | the parser finished reading a JSON value | depth of the value | the parsed JSON value
17762 
17763  @image html callback_events.png "Example when certain parse events are triggered"
17764 
17765  Discarding a value (i.e., returning `false`) has different effects
17766  depending on the context in which function was called:
17767 
17768  - Discarded values in structured types are skipped. That is, the parser
17769  will behave as if the discarded value was never read.
17770  - In case a value outside a structured type is skipped, it is replaced
17771  with `null`. This case happens if the top-level element is skipped.
17772 
17773  @param[in] depth the depth of the recursion during parsing
17774 
17775  @param[in] event an event of type parse_event_t indicating the context in
17776  the callback function has been called
17777 
17778  @param[in,out] parsed the current intermediate parse result; note that
17779  writing to this value has no effect for parse_event_t::key events
17780 
17781  @return Whether the JSON value which called the function during parsing
17782  should be kept (`true`) or not (`false`). In the latter case, it is either
17783  skipped completely or replaced by an empty discarded object.
17784 
17785  @sa @ref parse for examples
17786 
17787  @since version 1.0.0
17788  */
17789  using parser_callback_t = detail::parser_callback_t<basic_json>;
17790 
17791  //////////////////
17792  // constructors //
17793  //////////////////
17794 
17795  /// @name constructors and destructors
17796  /// Constructors of class @ref basic_json, copy/move constructor, copy
17797  /// assignment, static functions creating objects, and the destructor.
17798  /// @{
17799 
17800  /*!
17801  @brief create an empty value with a given type
17802 
17803  Create an empty JSON value with a given type. The value will be default
17804  initialized with an empty value which depends on the type:
17805 
17806  Value type | initial value
17807  ----------- | -------------
17808  null | `null`
17809  boolean | `false`
17810  string | `""`
17811  number | `0`
17812  object | `{}`
17813  array | `[]`
17814  binary | empty array
17815 
17816  @param[in] v the type of the value to create
17817 
17818  @complexity Constant.
17819 
17820  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
17821  changes to any JSON value.
17822 
17823  @liveexample{The following code shows the constructor for different @ref
17824  value_t values,basic_json__value_t}
17825 
17826  @sa @ref clear() -- restores the postcondition of this constructor
17827 
17828  @since version 1.0.0
17829  */
17831  : m_type(v), m_value(v)
17832  {
17833  assert_invariant();
17834  }
17835 
17836  /*!
17837  @brief create a null object
17838 
17839  Create a `null` JSON value. It either takes a null pointer as parameter
17840  (explicitly creating `null`) or no parameter (implicitly creating `null`).
17841  The passed null pointer itself is not read -- it is only used to choose
17842  the right constructor.
17843 
17844  @complexity Constant.
17845 
17846  @exceptionsafety No-throw guarantee: this constructor never throws
17847  exceptions.
17848 
17849  @liveexample{The following code shows the constructor with and without a
17850  null pointer parameter.,basic_json__nullptr_t}
17851 
17852  @since version 1.0.0
17853  */
17854  basic_json(std::nullptr_t = nullptr) noexcept
17855  : basic_json(value_t::null)
17856  {
17857  assert_invariant();
17858  }
17859 
17860  /*!
17861  @brief create a JSON value
17862 
17863  This is a "catch all" constructor for all compatible JSON types; that is,
17864  types for which a `to_json()` method exists. The constructor forwards the
17865  parameter @a val to that method (to `json_serializer<U>::to_json` method
17866  with `U = uncvref_t<CompatibleType>`, to be exact).
17867 
17868  Template type @a CompatibleType includes, but is not limited to, the
17869  following types:
17870  - **arrays**: @ref array_t and all kinds of compatible containers such as
17871  `std::vector`, `std::deque`, `std::list`, `std::forward_list`,
17872  `std::array`, `std::valarray`, `std::set`, `std::unordered_set`,
17873  `std::multiset`, and `std::unordered_multiset` with a `value_type` from
17874  which a @ref basic_json value can be constructed.
17875  - **objects**: @ref object_t and all kinds of compatible associative
17876  containers such as `std::map`, `std::unordered_map`, `std::multimap`,
17877  and `std::unordered_multimap` with a `key_type` compatible to
17878  @ref string_t and a `value_type` from which a @ref basic_json value can
17879  be constructed.
17880  - **strings**: @ref string_t, string literals, and all compatible string
17881  containers can be used.
17882  - **numbers**: @ref number_integer_t, @ref number_unsigned_t,
17883  @ref number_float_t, and all convertible number types such as `int`,
17884  `size_t`, `int64_t`, `float` or `double` can be used.
17885  - **boolean**: @ref boolean_t / `bool` can be used.
17886  - **binary**: @ref binary_t / `std::vector<uint8_t>` may be used,
17887  unfortunately because string literals cannot be distinguished from binary
17888  character arrays by the C++ type system, all types compatible with `const
17889  char*` will be directed to the string constructor instead. This is both
17890  for backwards compatibility, and due to the fact that a binary type is not
17891  a standard JSON type.
17892 
17893  See the examples below.
17894 
17895  @tparam CompatibleType a type such that:
17896  - @a CompatibleType is not derived from `std::istream`,
17897  - @a CompatibleType is not @ref basic_json (to avoid hijacking copy/move
17898  constructors),
17899  - @a CompatibleType is not a different @ref basic_json type (i.e. with different template arguments)
17900  - @a CompatibleType is not a @ref basic_json nested type (e.g.,
17901  @ref json_pointer, @ref iterator, etc ...)
17902  - @ref @ref json_serializer<U> has a
17903  `to_json(basic_json_t&, CompatibleType&&)` method
17904 
17905  @tparam U = `uncvref_t<CompatibleType>`
17906 
17907  @param[in] val the value to be forwarded to the respective constructor
17908 
17909  @complexity Usually linear in the size of the passed @a val, also
17910  depending on the implementation of the called `to_json()`
17911  method.
17912 
17913  @exceptionsafety Depends on the called constructor. For types directly
17914  supported by the library (i.e., all types for which no `to_json()` function
17915  was provided), strong guarantee holds: if an exception is thrown, there are
17916  no changes to any JSON value.
17917 
17918  @liveexample{The following code shows the constructor with several
17919  compatible types.,basic_json__CompatibleType}
17920 
17921  @since version 2.1.0
17922  */
17923  template < typename CompatibleType,
17924  typename U = detail::uncvref_t<CompatibleType>,
17925  detail::enable_if_t <
17927  basic_json(CompatibleType && val) noexcept(noexcept(
17928  JSONSerializer<U>::to_json(std::declval<basic_json_t&>(),
17929  std::forward<CompatibleType>(val))))
17930  {
17931  JSONSerializer<U>::to_json(*this, std::forward<CompatibleType>(val));
17932  assert_invariant();
17933  }
17934 
17935  /*!
17936  @brief create a JSON value from an existing one
17937 
17938  This is a constructor for existing @ref basic_json types.
17939  It does not hijack copy/move constructors, since the parameter has different
17940  template arguments than the current ones.
17941 
17942  The constructor tries to convert the internal @ref m_value of the parameter.
17943 
17944  @tparam BasicJsonType a type such that:
17945  - @a BasicJsonType is a @ref basic_json type.
17946  - @a BasicJsonType has different template arguments than @ref basic_json_t.
17947 
17948  @param[in] val the @ref basic_json value to be converted.
17949 
17950  @complexity Usually linear in the size of the passed @a val, also
17951  depending on the implementation of the called `to_json()`
17952  method.
17953 
17954  @exceptionsafety Depends on the called constructor. For types directly
17955  supported by the library (i.e., all types for which no `to_json()` function
17956  was provided), strong guarantee holds: if an exception is thrown, there are
17957  no changes to any JSON value.
17958 
17959  @since version 3.2.0
17960  */
17961  template < typename BasicJsonType,
17962  detail::enable_if_t <
17963  detail::is_basic_json<BasicJsonType>::value&& !std::is_same<basic_json, BasicJsonType>::value, int > = 0 >
17964  basic_json(const BasicJsonType& val)
17965  {
17966  using other_boolean_t = typename BasicJsonType::boolean_t;
17967  using other_number_float_t = typename BasicJsonType::number_float_t;
17968  using other_number_integer_t = typename BasicJsonType::number_integer_t;
17969  using other_number_unsigned_t = typename BasicJsonType::number_unsigned_t;
17970  using other_string_t = typename BasicJsonType::string_t;
17971  using other_object_t = typename BasicJsonType::object_t;
17972  using other_array_t = typename BasicJsonType::array_t;
17973  using other_binary_t = typename BasicJsonType::binary_t;
17974 
17975  switch (val.type())
17976  {
17977  case value_t::boolean:
17978  JSONSerializer<other_boolean_t>::to_json(*this, val.template get<other_boolean_t>());
17979  break;
17980  case value_t::number_float:
17981  JSONSerializer<other_number_float_t>::to_json(*this, val.template get<other_number_float_t>());
17982  break;
17984  JSONSerializer<other_number_integer_t>::to_json(*this, val.template get<other_number_integer_t>());
17985  break;
17987  JSONSerializer<other_number_unsigned_t>::to_json(*this, val.template get<other_number_unsigned_t>());
17988  break;
17989  case value_t::string:
17990  JSONSerializer<other_string_t>::to_json(*this, val.template get_ref<const other_string_t&>());
17991  break;
17992  case value_t::object:
17993  JSONSerializer<other_object_t>::to_json(*this, val.template get_ref<const other_object_t&>());
17994  break;
17995  case value_t::array:
17996  JSONSerializer<other_array_t>::to_json(*this, val.template get_ref<const other_array_t&>());
17997  break;
17998  case value_t::binary:
17999  JSONSerializer<other_binary_t>::to_json(*this, val.template get_ref<const other_binary_t&>());
18000  break;
18001  case value_t::null:
18002  *this = nullptr;
18003  break;
18004  case value_t::discarded:
18006  break;
18007  default: // LCOV_EXCL_LINE
18008  JSON_ASSERT(false); // LCOV_EXCL_LINE
18009  }
18010  assert_invariant();
18011  }
18012 
18013  /*!
18014  @brief create a container (array or object) from an initializer list
18015 
18016  Creates a JSON value of type array or object from the passed initializer
18017  list @a init. In case @a type_deduction is `true` (default), the type of
18018  the JSON value to be created is deducted from the initializer list @a init
18019  according to the following rules:
18020 
18021  1. If the list is empty, an empty JSON object value `{}` is created.
18022  2. If the list consists of pairs whose first element is a string, a JSON
18023  object value is created where the first elements of the pairs are
18024  treated as keys and the second elements are as values.
18025  3. In all other cases, an array is created.
18026 
18027  The rules aim to create the best fit between a C++ initializer list and
18028  JSON values. The rationale is as follows:
18029 
18030  1. The empty initializer list is written as `{}` which is exactly an empty
18031  JSON object.
18032  2. C++ has no way of describing mapped types other than to list a list of
18033  pairs. As JSON requires that keys must be of type string, rule 2 is the
18034  weakest constraint one can pose on initializer lists to interpret them
18035  as an object.
18036  3. In all other cases, the initializer list could not be interpreted as
18037  JSON object type, so interpreting it as JSON array type is safe.
18038 
18039  With the rules described above, the following JSON values cannot be
18040  expressed by an initializer list:
18041 
18042  - the empty array (`[]`): use @ref array(initializer_list_t)
18043  with an empty initializer list in this case
18044  - arrays whose elements satisfy rule 2: use @ref
18045  array(initializer_list_t) with the same initializer list
18046  in this case
18047 
18048  @note When used without parentheses around an empty initializer list, @ref
18049  basic_json() is called instead of this function, yielding the JSON null
18050  value.
18051 
18052  @param[in] init initializer list with JSON values
18053 
18054  @param[in] type_deduction internal parameter; when set to `true`, the type
18055  of the JSON value is deducted from the initializer list @a init; when set
18056  to `false`, the type provided via @a manual_type is forced. This mode is
18057  used by the functions @ref array(initializer_list_t) and
18058  @ref object(initializer_list_t).
18059 
18060  @param[in] manual_type internal parameter; when @a type_deduction is set
18061  to `false`, the created JSON value will use the provided type (only @ref
18062  value_t::array and @ref value_t::object are valid); when @a type_deduction
18063  is set to `true`, this parameter has no effect
18064 
18065  @throw type_error.301 if @a type_deduction is `false`, @a manual_type is
18066  `value_t::object`, but @a init contains an element which is not a pair
18067  whose first element is a string. In this case, the constructor could not
18068  create an object. If @a type_deduction would have be `true`, an array
18069  would have been created. See @ref object(initializer_list_t)
18070  for an example.
18071 
18072  @complexity Linear in the size of the initializer list @a init.
18073 
18074  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
18075  changes to any JSON value.
18076 
18077  @liveexample{The example below shows how JSON values are created from
18078  initializer lists.,basic_json__list_init_t}
18079 
18080  @sa @ref array(initializer_list_t) -- create a JSON array
18081  value from an initializer list
18082  @sa @ref object(initializer_list_t) -- create a JSON object
18083  value from an initializer list
18084 
18085  @since version 1.0.0
18086  */
18088  bool type_deduction = true,
18089  value_t manual_type = value_t::array)
18090  {
18091  // check if each element is an array with two elements whose first
18092  // element is a string
18093  bool is_an_object = std::all_of(init.begin(), init.end(),
18094  [](const detail::json_ref<basic_json>& element_ref)
18095  {
18096  return element_ref->is_array() && element_ref->size() == 2 && (*element_ref)[0].is_string();
18097  });
18098 
18099  // adjust type if type deduction is not wanted
18100  if (!type_deduction)
18101  {
18102  // if array is wanted, do not create an object though possible
18103  if (manual_type == value_t::array)
18104  {
18105  is_an_object = false;
18106  }
18107 
18108  // if object is wanted but impossible, throw an exception
18109  if (JSON_HEDLEY_UNLIKELY(manual_type == value_t::object && !is_an_object))
18110  {
18111  JSON_THROW(type_error::create(301, "cannot create object from initializer list"));
18112  }
18113  }
18114 
18115  if (is_an_object)
18116  {
18117  // the initializer list is a list of pairs -> create object
18120 
18121  std::for_each(init.begin(), init.end(), [this](const detail::json_ref<basic_json>& element_ref)
18122  {
18123  auto element = element_ref.moved_or_copied();
18124  m_value.object->emplace(
18125  std::move(*((*element.m_value.array)[0].m_value.string)),
18126  std::move((*element.m_value.array)[1]));
18127  });
18128  }
18129  else
18130  {
18131  // the initializer list describes an array -> create array
18133  m_value.array = create<array_t>(init.begin(), init.end());
18134  }
18135 
18136  assert_invariant();
18137  }
18138 
18139  /*!
18140  @brief explicitly create a binary array (without subtype)
18141 
18142  Creates a JSON binary array value from a given binary container. Binary
18143  values are part of various binary formats, such as CBOR, MessagePack, and
18144  BSON. This constructor is used to create a value for serialization to those
18145  formats.
18146 
18147  @note Note, this function exists because of the difficulty in correctly
18148  specifying the correct template overload in the standard value ctor, as both
18149  JSON arrays and JSON binary arrays are backed with some form of a
18150  `std::vector`. Because JSON binary arrays are a non-standard extension it
18151  was decided that it would be best to prevent automatic initialization of a
18152  binary array type, for backwards compatibility and so it does not happen on
18153  accident.
18154 
18155  @param[in] init container containing bytes to use as binary type
18156 
18157  @return JSON binary array value
18158 
18159  @complexity Linear in the size of @a init.
18160 
18161  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
18162  changes to any JSON value.
18163 
18164  @since version 3.8.0
18165  */
18166  JSON_HEDLEY_WARN_UNUSED_RESULT
18167  static basic_json binary(const typename binary_t::container_type& init)
18168  {
18169  auto res = basic_json();
18170  res.m_type = value_t::binary;
18171  res.m_value = init;
18172  return res;
18173  }
18174 
18175  /*!
18176  @brief explicitly create a binary array (with subtype)
18177 
18178  Creates a JSON binary array value from a given binary container. Binary
18179  values are part of various binary formats, such as CBOR, MessagePack, and
18180  BSON. This constructor is used to create a value for serialization to those
18181  formats.
18182 
18183  @note Note, this function exists because of the difficulty in correctly
18184  specifying the correct template overload in the standard value ctor, as both
18185  JSON arrays and JSON binary arrays are backed with some form of a
18186  `std::vector`. Because JSON binary arrays are a non-standard extension it
18187  was decided that it would be best to prevent automatic initialization of a
18188  binary array type, for backwards compatibility and so it does not happen on
18189  accident.
18190 
18191  @param[in] init container containing bytes to use as binary type
18192  @param[in] subtype subtype to use in MessagePack and BSON
18193 
18194  @return JSON binary array value
18195 
18196  @complexity Linear in the size of @a init.
18197 
18198  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
18199  changes to any JSON value.
18200 
18201  @since version 3.8.0
18202  */
18203  JSON_HEDLEY_WARN_UNUSED_RESULT
18204  static basic_json binary(const typename binary_t::container_type& init, std::uint8_t subtype)
18205  {
18206  auto res = basic_json();
18207  res.m_type = value_t::binary;
18208  res.m_value = binary_t(init, subtype);
18209  return res;
18210  }
18211 
18212  /// @copydoc binary(const typename binary_t::container_type&)
18213  JSON_HEDLEY_WARN_UNUSED_RESULT
18215  {
18216  auto res = basic_json();
18217  res.m_type = value_t::binary;
18218  res.m_value = std::move(init);
18219  return res;
18220  }
18221 
18222  /// @copydoc binary(const typename binary_t::container_type&, std::uint8_t)
18223  JSON_HEDLEY_WARN_UNUSED_RESULT
18224  static basic_json binary(typename binary_t::container_type&& init, std::uint8_t subtype)
18225  {
18226  auto res = basic_json();
18227  res.m_type = value_t::binary;
18228  res.m_value = binary_t(std::move(init), subtype);
18229  return res;
18230  }
18231 
18232  /*!
18233  @brief explicitly create an array from an initializer list
18234 
18235  Creates a JSON array value from a given initializer list. That is, given a
18236  list of values `a, b, c`, creates the JSON value `[a, b, c]`. If the
18237  initializer list is empty, the empty array `[]` is created.
18238 
18239  @note This function is only needed to express two edge cases that cannot
18240  be realized with the initializer list constructor (@ref
18241  basic_json(initializer_list_t, bool, value_t)). These cases
18242  are:
18243  1. creating an array whose elements are all pairs whose first element is a
18244  string -- in this case, the initializer list constructor would create an
18245  object, taking the first elements as keys
18246  2. creating an empty array -- passing the empty initializer list to the
18247  initializer list constructor yields an empty object
18248 
18249  @param[in] init initializer list with JSON values to create an array from
18250  (optional)
18251 
18252  @return JSON array value
18253 
18254  @complexity Linear in the size of @a init.
18255 
18256  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
18257  changes to any JSON value.
18258 
18259  @liveexample{The following code shows an example for the `array`
18260  function.,array}
18261 
18262  @sa @ref basic_json(initializer_list_t, bool, value_t) --
18263  create a JSON value from an initializer list
18264  @sa @ref object(initializer_list_t) -- create a JSON object
18265  value from an initializer list
18266 
18267  @since version 1.0.0
18268  */
18269  JSON_HEDLEY_WARN_UNUSED_RESULT
18271  {
18272  return basic_json(init, false, value_t::array);
18273  }
18274 
18275  /*!
18276  @brief explicitly create an object from an initializer list
18277 
18278  Creates a JSON object value from a given initializer list. The initializer
18279  lists elements must be pairs, and their first elements must be strings. If
18280  the initializer list is empty, the empty object `{}` is created.
18281 
18282  @note This function is only added for symmetry reasons. In contrast to the
18283  related function @ref array(initializer_list_t), there are
18284  no cases which can only be expressed by this function. That is, any
18285  initializer list @a init can also be passed to the initializer list
18286  constructor @ref basic_json(initializer_list_t, bool, value_t).
18287 
18288  @param[in] init initializer list to create an object from (optional)
18289 
18290  @return JSON object value
18291 
18292  @throw type_error.301 if @a init is not a list of pairs whose first
18293  elements are strings. In this case, no object can be created. When such a
18294  value is passed to @ref basic_json(initializer_list_t, bool, value_t),
18295  an array would have been created from the passed initializer list @a init.
18296  See example below.
18297 
18298  @complexity Linear in the size of @a init.
18299 
18300  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
18301  changes to any JSON value.
18302 
18303  @liveexample{The following code shows an example for the `object`
18304  function.,object}
18305 
18306  @sa @ref basic_json(initializer_list_t, bool, value_t) --
18307  create a JSON value from an initializer list
18308  @sa @ref array(initializer_list_t) -- create a JSON array
18309  value from an initializer list
18310 
18311  @since version 1.0.0
18312  */
18313  JSON_HEDLEY_WARN_UNUSED_RESULT
18315  {
18316  return basic_json(init, false, value_t::object);
18317  }
18318 
18319  /*!
18320  @brief construct an array with count copies of given value
18321 
18322  Constructs a JSON array value by creating @a cnt copies of a passed value.
18323  In case @a cnt is `0`, an empty array is created.
18324 
18325  @param[in] cnt the number of JSON copies of @a val to create
18326  @param[in] val the JSON value to copy
18327 
18328  @post `std::distance(begin(),end()) == cnt` holds.
18329 
18330  @complexity Linear in @a cnt.
18331 
18332  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
18333  changes to any JSON value.
18334 
18335  @liveexample{The following code shows examples for the @ref
18336  basic_json(size_type\, const basic_json&)
18337  constructor.,basic_json__size_type_basic_json}
18338 
18339  @since version 1.0.0
18340  */
18342  : m_type(value_t::array)
18343  {
18344  m_value.array = create<array_t>(cnt, val);
18345  assert_invariant();
18346  }
18347 
18348  /*!
18349  @brief construct a JSON container given an iterator range
18350 
18351  Constructs the JSON value with the contents of the range `[first, last)`.
18352  The semantics depends on the different types a JSON value can have:
18353  - In case of a null type, invalid_iterator.206 is thrown.
18354  - In case of other primitive types (number, boolean, or string), @a first
18355  must be `begin()` and @a last must be `end()`. In this case, the value is
18356  copied. Otherwise, invalid_iterator.204 is thrown.
18357  - In case of structured types (array, object), the constructor behaves as
18358  similar versions for `std::vector` or `std::map`; that is, a JSON array
18359  or object is constructed from the values in the range.
18360 
18361  @tparam InputIT an input iterator type (@ref iterator or @ref
18362  const_iterator)
18363 
18364  @param[in] first begin of the range to copy from (included)
18365  @param[in] last end of the range to copy from (excluded)
18366 
18367  @pre Iterators @a first and @a last must be initialized. **This
18368  precondition is enforced with an assertion (see warning).** If
18369  assertions are switched off, a violation of this precondition yields
18370  undefined behavior.
18371 
18372  @pre Range `[first, last)` is valid. Usually, this precondition cannot be
18373  checked efficiently. Only certain edge cases are detected; see the
18374  description of the exceptions below. A violation of this precondition
18375  yields undefined behavior.
18376 
18377  @warning A precondition is enforced with a runtime assertion that will
18378  result in calling `std::abort` if this precondition is not met.
18379  Assertions can be disabled by defining `NDEBUG` at compile time.
18380  See https://en.cppreference.com/w/cpp/error/assert for more
18381  information.
18382 
18383  @throw invalid_iterator.201 if iterators @a first and @a last are not
18384  compatible (i.e., do not belong to the same JSON value). In this case,
18385  the range `[first, last)` is undefined.
18386  @throw invalid_iterator.204 if iterators @a first and @a last belong to a
18387  primitive type (number, boolean, or string), but @a first does not point
18388  to the first element any more. In this case, the range `[first, last)` is
18389  undefined. See example code below.
18390  @throw invalid_iterator.206 if iterators @a first and @a last belong to a
18391  null value. In this case, the range `[first, last)` is undefined.
18392 
18393  @complexity Linear in distance between @a first and @a last.
18394 
18395  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
18396  changes to any JSON value.
18397 
18398  @liveexample{The example below shows several ways to create JSON values by
18399  specifying a subrange with iterators.,basic_json__InputIt_InputIt}
18400 
18401  @since version 1.0.0
18402  */
18403  template < class InputIT, typename std::enable_if <
18404  std::is_same<InputIT, typename basic_json_t::iterator>::value ||
18405  std::is_same<InputIT, typename basic_json_t::const_iterator>::value, int >::type = 0 >
18406  basic_json(InputIT first, InputIT last)
18407  {
18408  JSON_ASSERT(first.m_object != nullptr);
18409  JSON_ASSERT(last.m_object != nullptr);
18410 
18411  // make sure iterator fits the current value
18412  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
18413  {
18414  JSON_THROW(invalid_iterator::create(201, "iterators are not compatible"));
18415  }
18416 
18417  // copy type from first iterator
18418  m_type = first.m_object->m_type;
18419 
18420  // check if iterator range is complete for primitive values
18421  switch (m_type)
18422  {
18423  case value_t::boolean:
18424  case value_t::number_float:
18427  case value_t::string:
18428  {
18429  if (JSON_HEDLEY_UNLIKELY(!first.m_it.primitive_iterator.is_begin()
18430  || !last.m_it.primitive_iterator.is_end()))
18431  {
18432  JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
18433  }
18434  break;
18435  }
18436 
18437  default:
18438  break;
18439  }
18440 
18441  switch (m_type)
18442  {
18444  {
18445  m_value.number_integer = first.m_object->m_value.number_integer;
18446  break;
18447  }
18448 
18450  {
18451  m_value.number_unsigned = first.m_object->m_value.number_unsigned;
18452  break;
18453  }
18454 
18455  case value_t::number_float:
18456  {
18457  m_value.number_float = first.m_object->m_value.number_float;
18458  break;
18459  }
18460 
18461  case value_t::boolean:
18462  {
18463  m_value.boolean = first.m_object->m_value.boolean;
18464  break;
18465  }
18466 
18467  case value_t::string:
18468  {
18469  m_value = *first.m_object->m_value.string;
18470  break;
18471  }
18472 
18473  case value_t::object:
18474  {
18475  m_value.object = create<object_t>(first.m_it.object_iterator,
18476  last.m_it.object_iterator);
18477  break;
18478  }
18479 
18480  case value_t::array:
18481  {
18482  m_value.array = create<array_t>(first.m_it.array_iterator,
18483  last.m_it.array_iterator);
18484  break;
18485  }
18486 
18487  case value_t::binary:
18488  {
18489  m_value = *first.m_object->m_value.binary;
18490  break;
18491  }
18492 
18493  default:
18494  JSON_THROW(invalid_iterator::create(206, "cannot construct with iterators from " +
18495  std::string(first.m_object->type_name())));
18496  }
18497 
18498  assert_invariant();
18499  }
18500 
18501 
18502  ///////////////////////////////////////
18503  // other constructors and destructor //
18504  ///////////////////////////////////////
18505 
18506  template<typename JsonRef,
18507  detail::enable_if_t<detail::conjunction<detail::is_json_ref<JsonRef>,
18508  std::is_same<typename JsonRef::value_type, basic_json>>::value, int> = 0 >
18509  basic_json(const JsonRef& ref) : basic_json(ref.moved_or_copied()) {}
18510 
18511  /*!
18512  @brief copy constructor
18513 
18514  Creates a copy of a given JSON value.
18515 
18516  @param[in] other the JSON value to copy
18517 
18518  @post `*this == other`
18519 
18520  @complexity Linear in the size of @a other.
18521 
18522  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
18523  changes to any JSON value.
18524 
18525  @requirement This function helps `basic_json` satisfying the
18526  [Container](https://en.cppreference.com/w/cpp/named_req/Container)
18527  requirements:
18528  - The complexity is linear.
18529  - As postcondition, it holds: `other == basic_json(other)`.
18530 
18531  @liveexample{The following code shows an example for the copy
18532  constructor.,basic_json__basic_json}
18533 
18534  @since version 1.0.0
18535  */
18536  basic_json(const basic_json& other)
18537  : m_type(other.m_type)
18538  {
18539  // check of passed value is valid
18540  other.assert_invariant();
18541 
18542  switch (m_type)
18543  {
18544  case value_t::object:
18545  {
18546  m_value = *other.m_value.object;
18547  break;
18548  }
18549 
18550  case value_t::array:
18551  {
18552  m_value = *other.m_value.array;
18553  break;
18554  }
18555 
18556  case value_t::string:
18557  {
18558  m_value = *other.m_value.string;
18559  break;
18560  }
18561 
18562  case value_t::boolean:
18563  {
18564  m_value = other.m_value.boolean;
18565  break;
18566  }
18567 
18569  {
18570  m_value = other.m_value.number_integer;
18571  break;
18572  }
18573 
18575  {
18577  break;
18578  }
18579 
18580  case value_t::number_float:
18581  {
18582  m_value = other.m_value.number_float;
18583  break;
18584  }
18585 
18586  case value_t::binary:
18587  {
18588  m_value = *other.m_value.binary;
18589  break;
18590  }
18591 
18592  default:
18593  break;
18594  }
18595 
18596  assert_invariant();
18597  }
18598 
18599  /*!
18600  @brief move constructor
18601 
18602  Move constructor. Constructs a JSON value with the contents of the given
18603  value @a other using move semantics. It "steals" the resources from @a
18604  other and leaves it as JSON null value.
18605 
18606  @param[in,out] other value to move to this object
18607 
18608  @post `*this` has the same value as @a other before the call.
18609  @post @a other is a JSON null value.
18610 
18611  @complexity Constant.
18612 
18613  @exceptionsafety No-throw guarantee: this constructor never throws
18614  exceptions.
18615 
18616  @requirement This function helps `basic_json` satisfying the
18617  [MoveConstructible](https://en.cppreference.com/w/cpp/named_req/MoveConstructible)
18618  requirements.
18619 
18620  @liveexample{The code below shows the move constructor explicitly called
18621  via std::move.,basic_json__moveconstructor}
18622 
18623  @since version 1.0.0
18624  */
18625  basic_json(basic_json&& other) noexcept
18626  : m_type(std::move(other.m_type)),
18627  m_value(std::move(other.m_value))
18628  {
18629  // check that passed value is valid
18630  other.assert_invariant();
18631 
18632  // invalidate payload
18633  other.m_type = value_t::null;
18634  other.m_value = {};
18635 
18636  assert_invariant();
18637  }
18638 
18639  /*!
18640  @brief copy assignment
18641 
18642  Copy assignment operator. Copies a JSON value via the "copy and swap"
18643  strategy: It is expressed in terms of the copy constructor, destructor,
18644  and the `swap()` member function.
18645 
18646  @param[in] other value to copy from
18647 
18648  @complexity Linear.
18649 
18650  @requirement This function helps `basic_json` satisfying the
18651  [Container](https://en.cppreference.com/w/cpp/named_req/Container)
18652  requirements:
18653  - The complexity is linear.
18654 
18655  @liveexample{The code below shows and example for the copy assignment. It
18656  creates a copy of value `a` which is then swapped with `b`. Finally\, the
18657  copy of `a` (which is the null value after the swap) is
18658  destroyed.,basic_json__copyassignment}
18659 
18660  @since version 1.0.0
18661  */
18662  basic_json& operator=(basic_json other) noexcept (
18663  std::is_nothrow_move_constructible<value_t>::value&&
18664  std::is_nothrow_move_assignable<value_t>::value&&
18665  std::is_nothrow_move_constructible<json_value>::value&&
18666  std::is_nothrow_move_assignable<json_value>::value
18667  )
18668  {
18669  // check that passed value is valid
18670  other.assert_invariant();
18671 
18672  using std::swap;
18673  swap(m_type, other.m_type);
18674  swap(m_value, other.m_value);
18675 
18676  assert_invariant();
18677  return *this;
18678  }
18679 
18680  /*!
18681  @brief destructor
18682 
18683  Destroys the JSON value and frees all allocated memory.
18684 
18685  @complexity Linear.
18686 
18687  @requirement This function helps `basic_json` satisfying the
18688  [Container](https://en.cppreference.com/w/cpp/named_req/Container)
18689  requirements:
18690  - The complexity is linear.
18691  - All stored elements are destroyed and all memory is freed.
18692 
18693  @since version 1.0.0
18694  */
18695  ~basic_json() noexcept
18696  {
18697  assert_invariant();
18698  m_value.destroy(m_type);
18699  }
18700 
18701  /// @}
18702 
18703  public:
18704  ///////////////////////
18705  // object inspection //
18706  ///////////////////////
18707 
18708  /// @name object inspection
18709  /// Functions to inspect the type of a JSON value.
18710  /// @{
18711 
18712  /*!
18713  @brief serialization
18714 
18715  Serialization function for JSON values. The function tries to mimic
18716  Python's `json.dumps()` function, and currently supports its @a indent
18717  and @a ensure_ascii parameters.
18718 
18719  @param[in] indent If indent is nonnegative, then array elements and object
18720  members will be pretty-printed with that indent level. An indent level of
18721  `0` will only insert newlines. `-1` (the default) selects the most compact
18722  representation.
18723  @param[in] indent_char The character to use for indentation if @a indent is
18724  greater than `0`. The default is ` ` (space).
18725  @param[in] ensure_ascii If @a ensure_ascii is true, all non-ASCII characters
18726  in the output are escaped with `\uXXXX` sequences, and the result consists
18727  of ASCII characters only.
18728  @param[in] error_handler how to react on decoding errors; there are three
18729  possible values: `strict` (throws and exception in case a decoding error
18730  occurs; default), `replace` (replace invalid UTF-8 sequences with U+FFFD),
18731  and `ignore` (ignore invalid UTF-8 sequences during serialization; all
18732  bytes are copied to the output unchanged).
18733 
18734  @return string containing the serialization of the JSON value
18735 
18736  @throw type_error.316 if a string stored inside the JSON value is not
18737  UTF-8 encoded and @a error_handler is set to strict
18738 
18739  @note Binary values are serialized as object containing two keys:
18740  - "bytes": an array of bytes as integers
18741  - "subtype": the subtype as integer or "null" if the binary has no subtype
18742 
18743  @complexity Linear.
18744 
18745  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
18746  changes in the JSON value.
18747 
18748  @liveexample{The following example shows the effect of different @a indent\,
18749  @a indent_char\, and @a ensure_ascii parameters to the result of the
18750  serialization.,dump}
18751 
18752  @see https://docs.python.org/2/library/json.html#json.dump
18753 
18754  @since version 1.0.0; indentation character @a indent_char, option
18755  @a ensure_ascii and exceptions added in version 3.0.0; error
18756  handlers added in version 3.4.0; serialization of binary values added
18757  in version 3.8.0.
18758  */
18759  string_t dump(const int indent = -1,
18760  const char indent_char = ' ',
18761  const bool ensure_ascii = false,
18762  const error_handler_t error_handler = error_handler_t::strict) const
18763  {
18764  string_t result;
18765  serializer s(detail::output_adapter<char, string_t>(result), indent_char, error_handler);
18766 
18767  if (indent >= 0)
18768  {
18769  s.dump(*this, true, ensure_ascii, static_cast<unsigned int>(indent));
18770  }
18771  else
18772  {
18773  s.dump(*this, false, ensure_ascii, 0);
18774  }
18775 
18776  return result;
18777  }
18778 
18779  /*!
18780  @brief return the type of the JSON value (explicit)
18781 
18782  Return the type of the JSON value as a value from the @ref value_t
18783  enumeration.
18784 
18785  @return the type of the JSON value
18786  Value type | return value
18787  ------------------------- | -------------------------
18788  null | value_t::null
18789  boolean | value_t::boolean
18790  string | value_t::string
18791  number (integer) | value_t::number_integer
18792  number (unsigned integer) | value_t::number_unsigned
18793  number (floating-point) | value_t::number_float
18794  object | value_t::object
18795  array | value_t::array
18796  binary | value_t::binary
18797  discarded | value_t::discarded
18798 
18799  @complexity Constant.
18800 
18801  @exceptionsafety No-throw guarantee: this member function never throws
18802  exceptions.
18803 
18804  @liveexample{The following code exemplifies `type()` for all JSON
18805  types.,type}
18806 
18807  @sa @ref operator value_t() -- return the type of the JSON value (implicit)
18808  @sa @ref type_name() -- return the type as string
18809 
18810  @since version 1.0.0
18811  */
18812  constexpr value_t type() const noexcept
18813  {
18814  return m_type;
18815  }
18816 
18817  /*!
18818  @brief return whether type is primitive
18819 
18820  This function returns true if and only if the JSON type is primitive
18821  (string, number, boolean, or null).
18822 
18823  @return `true` if type is primitive (string, number, boolean, or null),
18824  `false` otherwise.
18825 
18826  @complexity Constant.
18827 
18828  @exceptionsafety No-throw guarantee: this member function never throws
18829  exceptions.
18830 
18831  @liveexample{The following code exemplifies `is_primitive()` for all JSON
18832  types.,is_primitive}
18833 
18834  @sa @ref is_structured() -- returns whether JSON value is structured
18835  @sa @ref is_null() -- returns whether JSON value is `null`
18836  @sa @ref is_string() -- returns whether JSON value is a string
18837  @sa @ref is_boolean() -- returns whether JSON value is a boolean
18838  @sa @ref is_number() -- returns whether JSON value is a number
18839  @sa @ref is_binary() -- returns whether JSON value is a binary array
18840 
18841  @since version 1.0.0
18842  */
18843  constexpr bool is_primitive() const noexcept
18844  {
18845  return is_null() || is_string() || is_boolean() || is_number() || is_binary();
18846  }
18847 
18848  /*!
18849  @brief return whether type is structured
18850 
18851  This function returns true if and only if the JSON type is structured
18852  (array or object).
18853 
18854  @return `true` if type is structured (array or object), `false` otherwise.
18855 
18856  @complexity Constant.
18857 
18858  @exceptionsafety No-throw guarantee: this member function never throws
18859  exceptions.
18860 
18861  @liveexample{The following code exemplifies `is_structured()` for all JSON
18862  types.,is_structured}
18863 
18864  @sa @ref is_primitive() -- returns whether value is primitive
18865  @sa @ref is_array() -- returns whether value is an array
18866  @sa @ref is_object() -- returns whether value is an object
18867 
18868  @since version 1.0.0
18869  */
18870  constexpr bool is_structured() const noexcept
18871  {
18872  return is_array() || is_object();
18873  }
18874 
18875  /*!
18876  @brief return whether value is null
18877 
18878  This function returns true if and only if the JSON value is null.
18879 
18880  @return `true` if type is null, `false` otherwise.
18881 
18882  @complexity Constant.
18883 
18884  @exceptionsafety No-throw guarantee: this member function never throws
18885  exceptions.
18886 
18887  @liveexample{The following code exemplifies `is_null()` for all JSON
18888  types.,is_null}
18889 
18890  @since version 1.0.0
18891  */
18892  constexpr bool is_null() const noexcept
18893  {
18894  return m_type == value_t::null;
18895  }
18896 
18897  /*!
18898  @brief return whether value is a boolean
18899 
18900  This function returns true if and only if the JSON value is a boolean.
18901 
18902  @return `true` if type is boolean, `false` otherwise.
18903 
18904  @complexity Constant.
18905 
18906  @exceptionsafety No-throw guarantee: this member function never throws
18907  exceptions.
18908 
18909  @liveexample{The following code exemplifies `is_boolean()` for all JSON
18910  types.,is_boolean}
18911 
18912  @since version 1.0.0
18913  */
18914  constexpr bool is_boolean() const noexcept
18915  {
18916  return m_type == value_t::boolean;
18917  }
18918 
18919  /*!
18920  @brief return whether value is a number
18921 
18922  This function returns true if and only if the JSON value is a number. This
18923  includes both integer (signed and unsigned) and floating-point values.
18924 
18925  @return `true` if type is number (regardless whether integer, unsigned
18926  integer or floating-type), `false` otherwise.
18927 
18928  @complexity Constant.
18929 
18930  @exceptionsafety No-throw guarantee: this member function never throws
18931  exceptions.
18932 
18933  @liveexample{The following code exemplifies `is_number()` for all JSON
18934  types.,is_number}
18935 
18936  @sa @ref is_number_integer() -- check if value is an integer or unsigned
18937  integer number
18938  @sa @ref is_number_unsigned() -- check if value is an unsigned integer
18939  number
18940  @sa @ref is_number_float() -- check if value is a floating-point number
18941 
18942  @since version 1.0.0
18943  */
18944  constexpr bool is_number() const noexcept
18945  {
18946  return is_number_integer() || is_number_float();
18947  }
18948 
18949  /*!
18950  @brief return whether value is an integer number
18951 
18952  This function returns true if and only if the JSON value is a signed or
18953  unsigned integer number. This excludes floating-point values.
18954 
18955  @return `true` if type is an integer or unsigned integer number, `false`
18956  otherwise.
18957 
18958  @complexity Constant.
18959 
18960  @exceptionsafety No-throw guarantee: this member function never throws
18961  exceptions.
18962 
18963  @liveexample{The following code exemplifies `is_number_integer()` for all
18964  JSON types.,is_number_integer}
18965 
18966  @sa @ref is_number() -- check if value is a number
18967  @sa @ref is_number_unsigned() -- check if value is an unsigned integer
18968  number
18969  @sa @ref is_number_float() -- check if value is a floating-point number
18970 
18971  @since version 1.0.0
18972  */
18973  constexpr bool is_number_integer() const noexcept
18974  {
18976  }
18977 
18978  /*!
18979  @brief return whether value is an unsigned integer number
18980 
18981  This function returns true if and only if the JSON value is an unsigned
18982  integer number. This excludes floating-point and signed integer values.
18983 
18984  @return `true` if type is an unsigned integer number, `false` otherwise.
18985 
18986  @complexity Constant.
18987 
18988  @exceptionsafety No-throw guarantee: this member function never throws
18989  exceptions.
18990 
18991  @liveexample{The following code exemplifies `is_number_unsigned()` for all
18992  JSON types.,is_number_unsigned}
18993 
18994  @sa @ref is_number() -- check if value is a number
18995  @sa @ref is_number_integer() -- check if value is an integer or unsigned
18996  integer number
18997  @sa @ref is_number_float() -- check if value is a floating-point number
18998 
18999  @since version 2.0.0
19000  */
19001  constexpr bool is_number_unsigned() const noexcept
19002  {
19003  return m_type == value_t::number_unsigned;
19004  }
19005 
19006  /*!
19007  @brief return whether value is a floating-point number
19008 
19009  This function returns true if and only if the JSON value is a
19010  floating-point number. This excludes signed and unsigned integer values.
19011 
19012  @return `true` if type is a floating-point number, `false` otherwise.
19013 
19014  @complexity Constant.
19015 
19016  @exceptionsafety No-throw guarantee: this member function never throws
19017  exceptions.
19018 
19019  @liveexample{The following code exemplifies `is_number_float()` for all
19020  JSON types.,is_number_float}
19021 
19022  @sa @ref is_number() -- check if value is number
19023  @sa @ref is_number_integer() -- check if value is an integer number
19024  @sa @ref is_number_unsigned() -- check if value is an unsigned integer
19025  number
19026 
19027  @since version 1.0.0
19028  */
19029  constexpr bool is_number_float() const noexcept
19030  {
19031  return m_type == value_t::number_float;
19032  }
19033 
19034  /*!
19035  @brief return whether value is an object
19036 
19037  This function returns true if and only if the JSON value is an object.
19038 
19039  @return `true` if type is object, `false` otherwise.
19040 
19041  @complexity Constant.
19042 
19043  @exceptionsafety No-throw guarantee: this member function never throws
19044  exceptions.
19045 
19046  @liveexample{The following code exemplifies `is_object()` for all JSON
19047  types.,is_object}
19048 
19049  @since version 1.0.0
19050  */
19051  constexpr bool is_object() const noexcept
19052  {
19053  return m_type == value_t::object;
19054  }
19055 
19056  /*!
19057  @brief return whether value is an array
19058 
19059  This function returns true if and only if the JSON value is an array.
19060 
19061  @return `true` if type is array, `false` otherwise.
19062 
19063  @complexity Constant.
19064 
19065  @exceptionsafety No-throw guarantee: this member function never throws
19066  exceptions.
19067 
19068  @liveexample{The following code exemplifies `is_array()` for all JSON
19069  types.,is_array}
19070 
19071  @since version 1.0.0
19072  */
19073  constexpr bool is_array() const noexcept
19074  {
19075  return m_type == value_t::array;
19076  }
19077 
19078  /*!
19079  @brief return whether value is a string
19080 
19081  This function returns true if and only if the JSON value is a string.
19082 
19083  @return `true` if type is string, `false` otherwise.
19084 
19085  @complexity Constant.
19086 
19087  @exceptionsafety No-throw guarantee: this member function never throws
19088  exceptions.
19089 
19090  @liveexample{The following code exemplifies `is_string()` for all JSON
19091  types.,is_string}
19092 
19093  @since version 1.0.0
19094  */
19095  constexpr bool is_string() const noexcept
19096  {
19097  return m_type == value_t::string;
19098  }
19099 
19100  /*!
19101  @brief return whether value is a binary array
19102 
19103  This function returns true if and only if the JSON value is a binary array.
19104 
19105  @return `true` if type is binary array, `false` otherwise.
19106 
19107  @complexity Constant.
19108 
19109  @exceptionsafety No-throw guarantee: this member function never throws
19110  exceptions.
19111 
19112  @liveexample{The following code exemplifies `is_binary()` for all JSON
19113  types.,is_binary}
19114 
19115  @since version 3.8.0
19116  */
19117  constexpr bool is_binary() const noexcept
19118  {
19119  return m_type == value_t::binary;
19120  }
19121 
19122  /*!
19123  @brief return whether value is discarded
19124 
19125  This function returns true if and only if the JSON value was discarded
19126  during parsing with a callback function (see @ref parser_callback_t).
19127 
19128  @note This function will always be `false` for JSON values after parsing.
19129  That is, discarded values can only occur during parsing, but will be
19130  removed when inside a structured value or replaced by null in other cases.
19131 
19132  @return `true` if type is discarded, `false` otherwise.
19133 
19134  @complexity Constant.
19135 
19136  @exceptionsafety No-throw guarantee: this member function never throws
19137  exceptions.
19138 
19139  @liveexample{The following code exemplifies `is_discarded()` for all JSON
19140  types.,is_discarded}
19141 
19142  @since version 1.0.0
19143  */
19144  constexpr bool is_discarded() const noexcept
19145  {
19146  return m_type == value_t::discarded;
19147  }
19148 
19149  /*!
19150  @brief return the type of the JSON value (implicit)
19151 
19152  Implicitly return the type of the JSON value as a value from the @ref
19153  value_t enumeration.
19154 
19155  @return the type of the JSON value
19156 
19157  @complexity Constant.
19158 
19159  @exceptionsafety No-throw guarantee: this member function never throws
19160  exceptions.
19161 
19162  @liveexample{The following code exemplifies the @ref value_t operator for
19163  all JSON types.,operator__value_t}
19164 
19165  @sa @ref type() -- return the type of the JSON value (explicit)
19166  @sa @ref type_name() -- return the type as string
19167 
19168  @since version 1.0.0
19169  */
19170  constexpr operator value_t() const noexcept
19171  {
19172  return m_type;
19173  }
19174 
19175  /// @}
19176 
19177  private:
19178  //////////////////
19179  // value access //
19180  //////////////////
19181 
19182  /// get a boolean (explicit)
19183  boolean_t get_impl(boolean_t* /*unused*/) const
19184  {
19185  if (JSON_HEDLEY_LIKELY(is_boolean()))
19186  {
19187  return m_value.boolean;
19188  }
19189 
19190  JSON_THROW(type_error::create(302, "type must be boolean, but is " + std::string(type_name())));
19191  }
19192 
19193  /// get a pointer to the value (object)
19194  object_t* get_impl_ptr(object_t* /*unused*/) noexcept
19195  {
19196  return is_object() ? m_value.object : nullptr;
19197  }
19198 
19199  /// get a pointer to the value (object)
19200  constexpr const object_t* get_impl_ptr(const object_t* /*unused*/) const noexcept
19201  {
19202  return is_object() ? m_value.object : nullptr;
19203  }
19204 
19205  /// get a pointer to the value (array)
19206  array_t* get_impl_ptr(array_t* /*unused*/) noexcept
19207  {
19208  return is_array() ? m_value.array : nullptr;
19209  }
19210 
19211  /// get a pointer to the value (array)
19212  constexpr const array_t* get_impl_ptr(const array_t* /*unused*/) const noexcept
19213  {
19214  return is_array() ? m_value.array : nullptr;
19215  }
19216 
19217  /// get a pointer to the value (string)
19218  string_t* get_impl_ptr(string_t* /*unused*/) noexcept
19219  {
19220  return is_string() ? m_value.string : nullptr;
19221  }
19222 
19223  /// get a pointer to the value (string)
19224  constexpr const string_t* get_impl_ptr(const string_t* /*unused*/) const noexcept
19225  {
19226  return is_string() ? m_value.string : nullptr;
19227  }
19228 
19229  /// get a pointer to the value (boolean)
19230  boolean_t* get_impl_ptr(boolean_t* /*unused*/) noexcept
19231  {
19232  return is_boolean() ? &m_value.boolean : nullptr;
19233  }
19234 
19235  /// get a pointer to the value (boolean)
19236  constexpr const boolean_t* get_impl_ptr(const boolean_t* /*unused*/) const noexcept
19237  {
19238  return is_boolean() ? &m_value.boolean : nullptr;
19239  }
19240 
19241  /// get a pointer to the value (integer number)
19243  {
19244  return is_number_integer() ? &m_value.number_integer : nullptr;
19245  }
19246 
19247  /// get a pointer to the value (integer number)
19248  constexpr const number_integer_t* get_impl_ptr(const number_integer_t* /*unused*/) const noexcept
19249  {
19250  return is_number_integer() ? &m_value.number_integer : nullptr;
19251  }
19252 
19253  /// get a pointer to the value (unsigned number)
19255  {
19256  return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
19257  }
19258 
19259  /// get a pointer to the value (unsigned number)
19260  constexpr const number_unsigned_t* get_impl_ptr(const number_unsigned_t* /*unused*/) const noexcept
19261  {
19262  return is_number_unsigned() ? &m_value.number_unsigned : nullptr;
19263  }
19264 
19265  /// get a pointer to the value (floating-point number)
19267  {
19268  return is_number_float() ? &m_value.number_float : nullptr;
19269  }
19270 
19271  /// get a pointer to the value (floating-point number)
19272  constexpr const number_float_t* get_impl_ptr(const number_float_t* /*unused*/) const noexcept
19273  {
19274  return is_number_float() ? &m_value.number_float : nullptr;
19275  }
19276 
19277  /// get a pointer to the value (binary)
19278  binary_t* get_impl_ptr(binary_t* /*unused*/) noexcept
19279  {
19280  return is_binary() ? m_value.binary : nullptr;
19281  }
19282 
19283  /// get a pointer to the value (binary)
19284  constexpr const binary_t* get_impl_ptr(const binary_t* /*unused*/) const noexcept
19285  {
19286  return is_binary() ? m_value.binary : nullptr;
19287  }
19288 
19289  /*!
19290  @brief helper function to implement get_ref()
19291 
19292  This function helps to implement get_ref() without code duplication for
19293  const and non-const overloads
19294 
19295  @tparam ThisType will be deduced as `basic_json` or `const basic_json`
19296 
19297  @throw type_error.303 if ReferenceType does not match underlying value
19298  type of the current JSON
19299  */
19300  template<typename ReferenceType, typename ThisType>
19301  static ReferenceType get_ref_impl(ThisType& obj)
19302  {
19303  // delegate the call to get_ptr<>()
19304  auto ptr = obj.template get_ptr<typename std::add_pointer<ReferenceType>::type>();
19305 
19306  if (JSON_HEDLEY_LIKELY(ptr != nullptr))
19307  {
19308  return *ptr;
19309  }
19310 
19311  JSON_THROW(type_error::create(303, "incompatible ReferenceType for get_ref, actual type is " + std::string(obj.type_name())));
19312  }
19313 
19314  public:
19315  /// @name value access
19316  /// Direct access to the stored value of a JSON value.
19317  /// @{
19318 
19319  /*!
19320  @brief get special-case overload
19321 
19322  This overloads avoids a lot of template boilerplate, it can be seen as the
19323  identity method
19324 
19325  @tparam BasicJsonType == @ref basic_json
19326 
19327  @return a copy of *this
19328 
19329  @complexity Constant.
19330 
19331  @since version 2.1.0
19332  */
19333  template<typename BasicJsonType, detail::enable_if_t<
19334  std::is_same<typename std::remove_const<BasicJsonType>::type, basic_json_t>::value,
19335  int> = 0>
19336  basic_json get() const
19337  {
19338  return *this;
19339  }
19340 
19341  /*!
19342  @brief get special-case overload
19343 
19344  This overloads converts the current @ref basic_json in a different
19345  @ref basic_json type
19346 
19347  @tparam BasicJsonType == @ref basic_json
19348 
19349  @return a copy of *this, converted into @tparam BasicJsonType
19350 
19351  @complexity Depending on the implementation of the called `from_json()`
19352  method.
19353 
19354  @since version 3.2.0
19355  */
19356  template < typename BasicJsonType, detail::enable_if_t <
19357  !std::is_same<BasicJsonType, basic_json>::value&&
19359  BasicJsonType get() const
19360  {
19361  return *this;
19362  }
19363 
19364  /*!
19365  @brief get a value (explicit)
19366 
19367  Explicit type conversion between the JSON value and a compatible value
19368  which is [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
19369  and [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
19370  The value is converted by calling the @ref json_serializer<ValueType>
19371  `from_json()` method.
19372 
19373  The function is equivalent to executing
19374  @code {.cpp}
19375  ValueType ret;
19376  JSONSerializer<ValueType>::from_json(*this, ret);
19377  return ret;
19378  @endcode
19379 
19380  This overloads is chosen if:
19381  - @a ValueType is not @ref basic_json,
19382  - @ref json_serializer<ValueType> has a `from_json()` method of the form
19383  `void from_json(const basic_json&, ValueType&)`, and
19384  - @ref json_serializer<ValueType> does not have a `from_json()` method of
19385  the form `ValueType from_json(const basic_json&)`
19386 
19387  @tparam ValueTypeCV the provided value type
19388  @tparam ValueType the returned value type
19389 
19390  @return copy of the JSON value, converted to @a ValueType
19391 
19392  @throw what @ref json_serializer<ValueType> `from_json()` method throws
19393 
19394  @liveexample{The example below shows several conversions from JSON values
19395  to other types. There a few things to note: (1) Floating-point numbers can
19396  be converted to integers\, (2) A JSON array can be converted to a standard
19397  `std::vector<short>`\, (3) A JSON object can be converted to C++
19398  associative containers such as `std::unordered_map<std::string\,
19399  json>`.,get__ValueType_const}
19400 
19401  @since version 2.1.0
19402  */
19403  template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
19404  detail::enable_if_t <
19405  !detail::is_basic_json<ValueType>::value &&
19406  detail::has_from_json<basic_json_t, ValueType>::value &&
19407  !detail::has_non_default_from_json<basic_json_t, ValueType>::value,
19408  int > = 0 >
19409  ValueType get() const noexcept(noexcept(
19410  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), std::declval<ValueType&>())))
19411  {
19412  // we cannot static_assert on ValueTypeCV being non-const, because
19413  // there is support for get<const basic_json_t>(), which is why we
19414  // still need the uncvref
19415  static_assert(!std::is_reference<ValueTypeCV>::value,
19416  "get() cannot be used with reference types, you might want to use get_ref()");
19417  static_assert(std::is_default_constructible<ValueType>::value,
19418  "types must be DefaultConstructible when used with get()");
19419 
19420  ValueType ret;
19421  JSONSerializer<ValueType>::from_json(*this, ret);
19422  return ret;
19423  }
19424 
19425  /*!
19426  @brief get a value (explicit); special case
19427 
19428  Explicit type conversion between the JSON value and a compatible value
19429  which is **not** [CopyConstructible](https://en.cppreference.com/w/cpp/named_req/CopyConstructible)
19430  and **not** [DefaultConstructible](https://en.cppreference.com/w/cpp/named_req/DefaultConstructible).
19431  The value is converted by calling the @ref json_serializer<ValueType>
19432  `from_json()` method.
19433 
19434  The function is equivalent to executing
19435  @code {.cpp}
19436  return JSONSerializer<ValueTypeCV>::from_json(*this);
19437  @endcode
19438 
19439  This overloads is chosen if:
19440  - @a ValueType is not @ref basic_json and
19441  - @ref json_serializer<ValueType> has a `from_json()` method of the form
19442  `ValueType from_json(const basic_json&)`
19443 
19444  @note If @ref json_serializer<ValueType> has both overloads of
19445  `from_json()`, this one is chosen.
19446 
19447  @tparam ValueTypeCV the provided value type
19448  @tparam ValueType the returned value type
19449 
19450  @return copy of the JSON value, converted to @a ValueType
19451 
19452  @throw what @ref json_serializer<ValueType> `from_json()` method throws
19453 
19454  @since version 2.1.0
19455  */
19456  template < typename ValueTypeCV, typename ValueType = detail::uncvref_t<ValueTypeCV>,
19457  detail::enable_if_t < !std::is_same<basic_json_t, ValueType>::value &&
19458  detail::has_non_default_from_json<basic_json_t, ValueType>::value,
19459  int > = 0 >
19460  ValueType get() const noexcept(noexcept(
19461  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>())))
19462  {
19463  static_assert(!std::is_reference<ValueTypeCV>::value,
19464  "get() cannot be used with reference types, you might want to use get_ref()");
19465  return JSONSerializer<ValueType>::from_json(*this);
19466  }
19467 
19468  /*!
19469  @brief get a value (explicit)
19470 
19471  Explicit type conversion between the JSON value and a compatible value.
19472  The value is filled into the input parameter by calling the @ref json_serializer<ValueType>
19473  `from_json()` method.
19474 
19475  The function is equivalent to executing
19476  @code {.cpp}
19477  ValueType v;
19478  JSONSerializer<ValueType>::from_json(*this, v);
19479  @endcode
19480 
19481  This overloads is chosen if:
19482  - @a ValueType is not @ref basic_json,
19483  - @ref json_serializer<ValueType> has a `from_json()` method of the form
19484  `void from_json(const basic_json&, ValueType&)`, and
19485 
19486  @tparam ValueType the input parameter type.
19487 
19488  @return the input parameter, allowing chaining calls.
19489 
19490  @throw what @ref json_serializer<ValueType> `from_json()` method throws
19491 
19492  @liveexample{The example below shows several conversions from JSON values
19493  to other types. There a few things to note: (1) Floating-point numbers can
19494  be converted to integers\, (2) A JSON array can be converted to a standard
19495  `std::vector<short>`\, (3) A JSON object can be converted to C++
19496  associative containers such as `std::unordered_map<std::string\,
19497  json>`.,get_to}
19498 
19499  @since version 3.3.0
19500  */
19501  template < typename ValueType,
19502  detail::enable_if_t <
19505  int > = 0 >
19506  ValueType & get_to(ValueType& v) const noexcept(noexcept(
19507  JSONSerializer<ValueType>::from_json(std::declval<const basic_json_t&>(), v)))
19508  {
19509  JSONSerializer<ValueType>::from_json(*this, v);
19510  return v;
19511  }
19512 
19513  // specialization to allow to call get_to with a basic_json value
19514  // see https://github.com/nlohmann/json/issues/2175
19515  template<typename ValueType,
19516  detail::enable_if_t <
19518  int> = 0>
19519  ValueType & get_to(ValueType& v) const
19520  {
19521  v = *this;
19522  return v;
19523  }
19524 
19525  template <
19526  typename T, std::size_t N,
19527  typename Array = T (&)[N],
19528  detail::enable_if_t <
19529  detail::has_from_json<basic_json_t, Array>::value, int > = 0 >
19530  Array get_to(T (&v)[N]) const
19531  noexcept(noexcept(JSONSerializer<Array>::from_json(
19532  std::declval<const basic_json_t&>(), v)))
19533  {
19534  JSONSerializer<Array>::from_json(*this, v);
19535  return v;
19536  }
19537 
19538 
19539  /*!
19540  @brief get a pointer value (implicit)
19541 
19542  Implicit pointer access to the internally stored JSON value. No copies are
19543  made.
19544 
19545  @warning Writing data to the pointee of the result yields an undefined
19546  state.
19547 
19548  @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
19549  object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
19550  @ref number_unsigned_t, or @ref number_float_t. Enforced by a static
19551  assertion.
19552 
19553  @return pointer to the internally stored JSON value if the requested
19554  pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
19555 
19556  @complexity Constant.
19557 
19558  @liveexample{The example below shows how pointers to internal values of a
19559  JSON value can be requested. Note that no type conversions are made and a
19560  `nullptr` is returned if the value and the requested pointer type does not
19561  match.,get_ptr}
19562 
19563  @since version 1.0.0
19564  */
19565  template<typename PointerType, typename std::enable_if<
19566  std::is_pointer<PointerType>::value, int>::type = 0>
19567  auto get_ptr() noexcept -> decltype(std::declval<basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
19568  {
19569  // delegate the call to get_impl_ptr<>()
19570  return get_impl_ptr(static_cast<PointerType>(nullptr));
19571  }
19572 
19573  /*!
19574  @brief get a pointer value (implicit)
19575  @copydoc get_ptr()
19576  */
19577  template < typename PointerType, typename std::enable_if <
19578  std::is_pointer<PointerType>::value&&
19579  std::is_const<typename std::remove_pointer<PointerType>::type>::value, int >::type = 0 >
19580  constexpr auto get_ptr() const noexcept -> decltype(std::declval<const basic_json_t&>().get_impl_ptr(std::declval<PointerType>()))
19581  {
19582  // delegate the call to get_impl_ptr<>() const
19583  return get_impl_ptr(static_cast<PointerType>(nullptr));
19584  }
19585 
19586  /*!
19587  @brief get a pointer value (explicit)
19588 
19589  Explicit pointer access to the internally stored JSON value. No copies are
19590  made.
19591 
19592  @warning The pointer becomes invalid if the underlying JSON object
19593  changes.
19594 
19595  @tparam PointerType pointer type; must be a pointer to @ref array_t, @ref
19596  object_t, @ref string_t, @ref boolean_t, @ref number_integer_t,
19597  @ref number_unsigned_t, or @ref number_float_t.
19598 
19599  @return pointer to the internally stored JSON value if the requested
19600  pointer type @a PointerType fits to the JSON value; `nullptr` otherwise
19601 
19602  @complexity Constant.
19603 
19604  @liveexample{The example below shows how pointers to internal values of a
19605  JSON value can be requested. Note that no type conversions are made and a
19606  `nullptr` is returned if the value and the requested pointer type does not
19607  match.,get__PointerType}
19608 
19609  @sa @ref get_ptr() for explicit pointer-member access
19610 
19611  @since version 1.0.0
19612  */
19613  template<typename PointerType, typename std::enable_if<
19614  std::is_pointer<PointerType>::value, int>::type = 0>
19615  auto get() noexcept -> decltype(std::declval<basic_json_t&>().template get_ptr<PointerType>())
19616  {
19617  // delegate the call to get_ptr
19618  return get_ptr<PointerType>();
19619  }
19620 
19621  /*!
19622  @brief get a pointer value (explicit)
19623  @copydoc get()
19624  */
19625  template<typename PointerType, typename std::enable_if<
19626  std::is_pointer<PointerType>::value, int>::type = 0>
19627  constexpr auto get() const noexcept -> decltype(std::declval<const basic_json_t&>().template get_ptr<PointerType>())
19628  {
19629  // delegate the call to get_ptr
19630  return get_ptr<PointerType>();
19631  }
19632 
19633  /*!
19634  @brief get a reference value (implicit)
19635 
19636  Implicit reference access to the internally stored JSON value. No copies
19637  are made.
19638 
19639  @warning Writing data to the referee of the result yields an undefined
19640  state.
19641 
19642  @tparam ReferenceType reference type; must be a reference to @ref array_t,
19643  @ref object_t, @ref string_t, @ref boolean_t, @ref number_integer_t, or
19644  @ref number_float_t. Enforced by static assertion.
19645 
19646  @return reference to the internally stored JSON value if the requested
19647  reference type @a ReferenceType fits to the JSON value; throws
19648  type_error.303 otherwise
19649 
19650  @throw type_error.303 in case passed type @a ReferenceType is incompatible
19651  with the stored JSON value; see example below
19652 
19653  @complexity Constant.
19654 
19655  @liveexample{The example shows several calls to `get_ref()`.,get_ref}
19656 
19657  @since version 1.1.0
19658  */
19659  template<typename ReferenceType, typename std::enable_if<
19660  std::is_reference<ReferenceType>::value, int>::type = 0>
19661  ReferenceType get_ref()
19662  {
19663  // delegate call to get_ref_impl
19664  return get_ref_impl<ReferenceType>(*this);
19665  }
19666 
19667  /*!
19668  @brief get a reference value (implicit)
19669  @copydoc get_ref()
19670  */
19671  template < typename ReferenceType, typename std::enable_if <
19672  std::is_reference<ReferenceType>::value&&
19673  std::is_const<typename std::remove_reference<ReferenceType>::type>::value, int >::type = 0 >
19674  ReferenceType get_ref() const
19675  {
19676  // delegate call to get_ref_impl
19677  return get_ref_impl<ReferenceType>(*this);
19678  }
19679 
19680  /*!
19681  @brief get a value (implicit)
19682 
19683  Implicit type conversion between the JSON value and a compatible value.
19684  The call is realized by calling @ref get() const.
19685 
19686  @tparam ValueType non-pointer type compatible to the JSON value, for
19687  instance `int` for JSON integer numbers, `bool` for JSON booleans, or
19688  `std::vector` types for JSON arrays. The character type of @ref string_t
19689  as well as an initializer list of this type is excluded to avoid
19690  ambiguities as these types implicitly convert to `std::string`.
19691 
19692  @return copy of the JSON value, converted to type @a ValueType
19693 
19694  @throw type_error.302 in case passed type @a ValueType is incompatible
19695  to the JSON value type (e.g., the JSON value is of type boolean, but a
19696  string is requested); see example below
19697 
19698  @complexity Linear in the size of the JSON value.
19699 
19700  @liveexample{The example below shows several conversions from JSON values
19701  to other types. There a few things to note: (1) Floating-point numbers can
19702  be converted to integers\, (2) A JSON array can be converted to a standard
19703  `std::vector<short>`\, (3) A JSON object can be converted to C++
19704  associative containers such as `std::unordered_map<std::string\,
19705  json>`.,operator__ValueType}
19706 
19707  @since version 1.0.0
19708  */
19709  template < typename ValueType, typename std::enable_if <
19710  !std::is_pointer<ValueType>::value&&
19711  !std::is_same<ValueType, detail::json_ref<basic_json>>::value&&
19712  !std::is_same<ValueType, typename string_t::value_type>::value&&
19714  && !std::is_same<ValueType, std::initializer_list<typename string_t::value_type>>::value
19715 #if defined(JSON_HAS_CPP_17) && (defined(__GNUC__) || (defined(_MSC_VER) && _MSC_VER >= 1910 && _MSC_VER <= 1914))
19716  && !std::is_same<ValueType, typename std::string_view>::value
19717 #endif
19718  && detail::is_detected<detail::get_template_function, const basic_json_t&, ValueType>::value
19719  , int >::type = 0 >
19720  JSON_EXPLICIT operator ValueType() const
19721  {
19722  // delegate the call to get<>() const
19723  return get<ValueType>();
19724  }
19725 
19726  /*!
19727  @return reference to the binary value
19728 
19729  @throw type_error.302 if the value is not binary
19730 
19731  @sa @ref is_binary() to check if the value is binary
19732 
19733  @since version 3.8.0
19734  */
19736  {
19737  if (!is_binary())
19738  {
19739  JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
19740  }
19741 
19742  return *get_ptr<binary_t*>();
19743  }
19744 
19745  /// @copydoc get_binary()
19746  const binary_t& get_binary() const
19747  {
19748  if (!is_binary())
19749  {
19750  JSON_THROW(type_error::create(302, "type must be binary, but is " + std::string(type_name())));
19751  }
19752 
19753  return *get_ptr<const binary_t*>();
19754  }
19755 
19756  /// @}
19757 
19758 
19759  ////////////////////
19760  // element access //
19761  ////////////////////
19762 
19763  /// @name element access
19764  /// Access to the JSON value.
19765  /// @{
19766 
19767  /*!
19768  @brief access specified array element with bounds checking
19769 
19770  Returns a reference to the element at specified location @a idx, with
19771  bounds checking.
19772 
19773  @param[in] idx index of the element to access
19774 
19775  @return reference to the element at index @a idx
19776 
19777  @throw type_error.304 if the JSON value is not an array; in this case,
19778  calling `at` with an index makes no sense. See example below.
19779  @throw out_of_range.401 if the index @a idx is out of range of the array;
19780  that is, `idx >= size()`. See example below.
19781 
19782  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
19783  changes in the JSON value.
19784 
19785  @complexity Constant.
19786 
19787  @since version 1.0.0
19788 
19789  @liveexample{The example below shows how array elements can be read and
19790  written using `at()`. It also demonstrates the different exceptions that
19791  can be thrown.,at__size_type}
19792  */
19794  {
19795  // at only works for arrays
19796  if (JSON_HEDLEY_LIKELY(is_array()))
19797  {
19798  JSON_TRY
19799  {
19800  return m_value.array->at(idx);
19801  }
19802  JSON_CATCH (std::out_of_range&)
19803  {
19804  // create better exception explanation
19805  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
19806  }
19807  }
19808  else
19809  {
19810  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
19811  }
19812  }
19813 
19814  /*!
19815  @brief access specified array element with bounds checking
19816 
19817  Returns a const reference to the element at specified location @a idx,
19818  with bounds checking.
19819 
19820  @param[in] idx index of the element to access
19821 
19822  @return const reference to the element at index @a idx
19823 
19824  @throw type_error.304 if the JSON value is not an array; in this case,
19825  calling `at` with an index makes no sense. See example below.
19826  @throw out_of_range.401 if the index @a idx is out of range of the array;
19827  that is, `idx >= size()`. See example below.
19828 
19829  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
19830  changes in the JSON value.
19831 
19832  @complexity Constant.
19833 
19834  @since version 1.0.0
19835 
19836  @liveexample{The example below shows how array elements can be read using
19837  `at()`. It also demonstrates the different exceptions that can be thrown.,
19838  at__size_type_const}
19839  */
19841  {
19842  // at only works for arrays
19843  if (JSON_HEDLEY_LIKELY(is_array()))
19844  {
19845  JSON_TRY
19846  {
19847  return m_value.array->at(idx);
19848  }
19849  JSON_CATCH (std::out_of_range&)
19850  {
19851  // create better exception explanation
19852  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
19853  }
19854  }
19855  else
19856  {
19857  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
19858  }
19859  }
19860 
19861  /*!
19862  @brief access specified object element with bounds checking
19863 
19864  Returns a reference to the element at with specified key @a key, with
19865  bounds checking.
19866 
19867  @param[in] key key of the element to access
19868 
19869  @return reference to the element at key @a key
19870 
19871  @throw type_error.304 if the JSON value is not an object; in this case,
19872  calling `at` with a key makes no sense. See example below.
19873  @throw out_of_range.403 if the key @a key is is not stored in the object;
19874  that is, `find(key) == end()`. See example below.
19875 
19876  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
19877  changes in the JSON value.
19878 
19879  @complexity Logarithmic in the size of the container.
19880 
19881  @sa @ref operator[](const typename object_t::key_type&) for unchecked
19882  access by reference
19883  @sa @ref value() for access by value with a default value
19884 
19885  @since version 1.0.0
19886 
19887  @liveexample{The example below shows how object elements can be read and
19888  written using `at()`. It also demonstrates the different exceptions that
19889  can be thrown.,at__object_t_key_type}
19890  */
19891  reference at(const typename object_t::key_type& key)
19892  {
19893  // at only works for objects
19894  if (JSON_HEDLEY_LIKELY(is_object()))
19895  {
19896  JSON_TRY
19897  {
19898  return m_value.object->at(key);
19899  }
19900  JSON_CATCH (std::out_of_range&)
19901  {
19902  // create better exception explanation
19903  JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
19904  }
19905  }
19906  else
19907  {
19908  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
19909  }
19910  }
19911 
19912  /*!
19913  @brief access specified object element with bounds checking
19914 
19915  Returns a const reference to the element at with specified key @a key,
19916  with bounds checking.
19917 
19918  @param[in] key key of the element to access
19919 
19920  @return const reference to the element at key @a key
19921 
19922  @throw type_error.304 if the JSON value is not an object; in this case,
19923  calling `at` with a key makes no sense. See example below.
19924  @throw out_of_range.403 if the key @a key is is not stored in the object;
19925  that is, `find(key) == end()`. See example below.
19926 
19927  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
19928  changes in the JSON value.
19929 
19930  @complexity Logarithmic in the size of the container.
19931 
19932  @sa @ref operator[](const typename object_t::key_type&) for unchecked
19933  access by reference
19934  @sa @ref value() for access by value with a default value
19935 
19936  @since version 1.0.0
19937 
19938  @liveexample{The example below shows how object elements can be read using
19939  `at()`. It also demonstrates the different exceptions that can be thrown.,
19940  at__object_t_key_type_const}
19941  */
19942  const_reference at(const typename object_t::key_type& key) const
19943  {
19944  // at only works for objects
19945  if (JSON_HEDLEY_LIKELY(is_object()))
19946  {
19947  JSON_TRY
19948  {
19949  return m_value.object->at(key);
19950  }
19951  JSON_CATCH (std::out_of_range&)
19952  {
19953  // create better exception explanation
19954  JSON_THROW(out_of_range::create(403, "key '" + key + "' not found"));
19955  }
19956  }
19957  else
19958  {
19959  JSON_THROW(type_error::create(304, "cannot use at() with " + std::string(type_name())));
19960  }
19961  }
19962 
19963  /*!
19964  @brief access specified array element
19965 
19966  Returns a reference to the element at specified location @a idx.
19967 
19968  @note If @a idx is beyond the range of the array (i.e., `idx >= size()`),
19969  then the array is silently filled up with `null` values to make `idx` a
19970  valid reference to the last stored element.
19971 
19972  @param[in] idx index of the element to access
19973 
19974  @return reference to the element at index @a idx
19975 
19976  @throw type_error.305 if the JSON value is not an array or null; in that
19977  cases, using the [] operator with an index makes no sense.
19978 
19979  @complexity Constant if @a idx is in the range of the array. Otherwise
19980  linear in `idx - size()`.
19981 
19982  @liveexample{The example below shows how array elements can be read and
19983  written using `[]` operator. Note the addition of `null`
19984  values.,operatorarray__size_type}
19985 
19986  @since version 1.0.0
19987  */
19989  {
19990  // implicitly convert null value to an empty array
19991  if (is_null())
19992  {
19994  m_value.array = create<array_t>();
19995  assert_invariant();
19996  }
19997 
19998  // operator[] only works for arrays
19999  if (JSON_HEDLEY_LIKELY(is_array()))
20000  {
20001  // fill up array with null values if given idx is outside range
20002  if (idx >= m_value.array->size())
20003  {
20004  m_value.array->insert(m_value.array->end(),
20005  idx - m_value.array->size() + 1,
20006  basic_json());
20007  }
20008 
20009  return m_value.array->operator[](idx);
20010  }
20011 
20012  JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
20013  }
20014 
20015  /*!
20016  @brief access specified array element
20017 
20018  Returns a const reference to the element at specified location @a idx.
20019 
20020  @param[in] idx index of the element to access
20021 
20022  @return const reference to the element at index @a idx
20023 
20024  @throw type_error.305 if the JSON value is not an array; in that case,
20025  using the [] operator with an index makes no sense.
20026 
20027  @complexity Constant.
20028 
20029  @liveexample{The example below shows how array elements can be read using
20030  the `[]` operator.,operatorarray__size_type_const}
20031 
20032  @since version 1.0.0
20033  */
20035  {
20036  // const operator[] only works for arrays
20037  if (JSON_HEDLEY_LIKELY(is_array()))
20038  {
20039  return m_value.array->operator[](idx);
20040  }
20041 
20042  JSON_THROW(type_error::create(305, "cannot use operator[] with a numeric argument with " + std::string(type_name())));
20043  }
20044 
20045  /*!
20046  @brief access specified object element
20047 
20048  Returns a reference to the element at with specified key @a key.
20049 
20050  @note If @a key is not found in the object, then it is silently added to
20051  the object and filled with a `null` value to make `key` a valid reference.
20052  In case the value was `null` before, it is converted to an object.
20053 
20054  @param[in] key key of the element to access
20055 
20056  @return reference to the element at key @a key
20057 
20058  @throw type_error.305 if the JSON value is not an object or null; in that
20059  cases, using the [] operator with a key makes no sense.
20060 
20061  @complexity Logarithmic in the size of the container.
20062 
20063  @liveexample{The example below shows how object elements can be read and
20064  written using the `[]` operator.,operatorarray__key_type}
20065 
20066  @sa @ref at(const typename object_t::key_type&) for access by reference
20067  with range checking
20068  @sa @ref value() for access by value with a default value
20069 
20070  @since version 1.0.0
20071  */
20072  reference operator[](const typename object_t::key_type& key)
20073  {
20074  // implicitly convert null value to an empty object
20075  if (is_null())
20076  {
20078  m_value.object = create<object_t>();
20079  assert_invariant();
20080  }
20081 
20082  // operator[] only works for objects
20083  if (JSON_HEDLEY_LIKELY(is_object()))
20084  {
20085  return m_value.object->operator[](key);
20086  }
20087 
20088  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
20089  }
20090 
20091  /*!
20092  @brief read-only access specified object element
20093 
20094  Returns a const reference to the element at with specified key @a key. No
20095  bounds checking is performed.
20096 
20097  @warning If the element with key @a key does not exist, the behavior is
20098  undefined.
20099 
20100  @param[in] key key of the element to access
20101 
20102  @return const reference to the element at key @a key
20103 
20104  @pre The element with key @a key must exist. **This precondition is
20105  enforced with an assertion.**
20106 
20107  @throw type_error.305 if the JSON value is not an object; in that case,
20108  using the [] operator with a key makes no sense.
20109 
20110  @complexity Logarithmic in the size of the container.
20111 
20112  @liveexample{The example below shows how object elements can be read using
20113  the `[]` operator.,operatorarray__key_type_const}
20114 
20115  @sa @ref at(const typename object_t::key_type&) for access by reference
20116  with range checking
20117  @sa @ref value() for access by value with a default value
20118 
20119  @since version 1.0.0
20120  */
20121  const_reference operator[](const typename object_t::key_type& key) const
20122  {
20123  // const operator[] only works for objects
20124  if (JSON_HEDLEY_LIKELY(is_object()))
20125  {
20126  JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
20127  return m_value.object->find(key)->second;
20128  }
20129 
20130  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
20131  }
20132 
20133  /*!
20134  @brief access specified object element
20135 
20136  Returns a reference to the element at with specified key @a key.
20137 
20138  @note If @a key is not found in the object, then it is silently added to
20139  the object and filled with a `null` value to make `key` a valid reference.
20140  In case the value was `null` before, it is converted to an object.
20141 
20142  @param[in] key key of the element to access
20143 
20144  @return reference to the element at key @a key
20145 
20146  @throw type_error.305 if the JSON value is not an object or null; in that
20147  cases, using the [] operator with a key makes no sense.
20148 
20149  @complexity Logarithmic in the size of the container.
20150 
20151  @liveexample{The example below shows how object elements can be read and
20152  written using the `[]` operator.,operatorarray__key_type}
20153 
20154  @sa @ref at(const typename object_t::key_type&) for access by reference
20155  with range checking
20156  @sa @ref value() for access by value with a default value
20157 
20158  @since version 1.1.0
20159  */
20160  template<typename T>
20161  JSON_HEDLEY_NON_NULL(2)
20162  reference operator[](T* key)
20163  {
20164  // implicitly convert null to object
20165  if (is_null())
20166  {
20169  assert_invariant();
20170  }
20171 
20172  // at only works for objects
20173  if (JSON_HEDLEY_LIKELY(is_object()))
20174  {
20175  return m_value.object->operator[](key);
20176  }
20177 
20178  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
20179  }
20180 
20181  /*!
20182  @brief read-only access specified object element
20183 
20184  Returns a const reference to the element at with specified key @a key. No
20185  bounds checking is performed.
20186 
20187  @warning If the element with key @a key does not exist, the behavior is
20188  undefined.
20189 
20190  @param[in] key key of the element to access
20191 
20192  @return const reference to the element at key @a key
20193 
20194  @pre The element with key @a key must exist. **This precondition is
20195  enforced with an assertion.**
20196 
20197  @throw type_error.305 if the JSON value is not an object; in that case,
20198  using the [] operator with a key makes no sense.
20199 
20200  @complexity Logarithmic in the size of the container.
20201 
20202  @liveexample{The example below shows how object elements can be read using
20203  the `[]` operator.,operatorarray__key_type_const}
20204 
20205  @sa @ref at(const typename object_t::key_type&) for access by reference
20206  with range checking
20207  @sa @ref value() for access by value with a default value
20208 
20209  @since version 1.1.0
20210  */
20211  template<typename T>
20212  JSON_HEDLEY_NON_NULL(2)
20213  const_reference operator[](T* key) const
20214  {
20215  // at only works for objects
20216  if (JSON_HEDLEY_LIKELY(is_object()))
20217  {
20218  JSON_ASSERT(m_value.object->find(key) != m_value.object->end());
20219  return m_value.object->find(key)->second;
20220  }
20221 
20222  JSON_THROW(type_error::create(305, "cannot use operator[] with a string argument with " + std::string(type_name())));
20223  }
20224 
20225  /*!
20226  @brief access specified object element with default value
20227 
20228  Returns either a copy of an object's element at the specified key @a key
20229  or a given default value if no element with key @a key exists.
20230 
20231  The function is basically equivalent to executing
20232  @code {.cpp}
20233  try {
20234  return at(key);
20235  } catch(out_of_range) {
20236  return default_value;
20237  }
20238  @endcode
20239 
20240  @note Unlike @ref at(const typename object_t::key_type&), this function
20241  does not throw if the given key @a key was not found.
20242 
20243  @note Unlike @ref operator[](const typename object_t::key_type& key), this
20244  function does not implicitly add an element to the position defined by @a
20245  key. This function is furthermore also applicable to const objects.
20246 
20247  @param[in] key key of the element to access
20248  @param[in] default_value the value to return if @a key is not found
20249 
20250  @tparam ValueType type compatible to JSON values, for instance `int` for
20251  JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
20252  JSON arrays. Note the type of the expected value at @a key and the default
20253  value @a default_value must be compatible.
20254 
20255  @return copy of the element at key @a key or @a default_value if @a key
20256  is not found
20257 
20258  @throw type_error.302 if @a default_value does not match the type of the
20259  value at @a key
20260  @throw type_error.306 if the JSON value is not an object; in that case,
20261  using `value()` with a key makes no sense.
20262 
20263  @complexity Logarithmic in the size of the container.
20264 
20265  @liveexample{The example below shows how object elements can be queried
20266  with a default value.,basic_json__value}
20267 
20268  @sa @ref at(const typename object_t::key_type&) for access by reference
20269  with range checking
20270  @sa @ref operator[](const typename object_t::key_type&) for unchecked
20271  access by reference
20272 
20273  @since version 1.0.0
20274  */
20275  // using std::is_convertible in a std::enable_if will fail when using explicit conversions
20276  template < class ValueType, typename std::enable_if <
20278  && !std::is_same<value_t, ValueType>::value, int >::type = 0 >
20279  ValueType value(const typename object_t::key_type& key, const ValueType& default_value) const
20280  {
20281  // at only works for objects
20282  if (JSON_HEDLEY_LIKELY(is_object()))
20283  {
20284  // if key is found, return value and given default value otherwise
20285  const auto it = find(key);
20286  if (it != end())
20287  {
20288  return it->template get<ValueType>();
20289  }
20290 
20291  return default_value;
20292  }
20293 
20294  JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
20295  }
20296 
20297  /*!
20298  @brief overload for a default value of type const char*
20299  @copydoc basic_json::value(const typename object_t::key_type&, const ValueType&) const
20300  */
20301  string_t value(const typename object_t::key_type& key, const char* default_value) const
20302  {
20303  return value(key, string_t(default_value));
20304  }
20305 
20306  /*!
20307  @brief access specified object element via JSON Pointer with default value
20308 
20309  Returns either a copy of an object's element at the specified key @a key
20310  or a given default value if no element with key @a key exists.
20311 
20312  The function is basically equivalent to executing
20313  @code {.cpp}
20314  try {
20315  return at(ptr);
20316  } catch(out_of_range) {
20317  return default_value;
20318  }
20319  @endcode
20320 
20321  @note Unlike @ref at(const json_pointer&), this function does not throw
20322  if the given key @a key was not found.
20323 
20324  @param[in] ptr a JSON pointer to the element to access
20325  @param[in] default_value the value to return if @a ptr found no value
20326 
20327  @tparam ValueType type compatible to JSON values, for instance `int` for
20328  JSON integer numbers, `bool` for JSON booleans, or `std::vector` types for
20329  JSON arrays. Note the type of the expected value at @a key and the default
20330  value @a default_value must be compatible.
20331 
20332  @return copy of the element at key @a key or @a default_value if @a key
20333  is not found
20334 
20335  @throw type_error.302 if @a default_value does not match the type of the
20336  value at @a ptr
20337  @throw type_error.306 if the JSON value is not an object; in that case,
20338  using `value()` with a key makes no sense.
20339 
20340  @complexity Logarithmic in the size of the container.
20341 
20342  @liveexample{The example below shows how object elements can be queried
20343  with a default value.,basic_json__value_ptr}
20344 
20345  @sa @ref operator[](const json_pointer&) for unchecked access by reference
20346 
20347  @since version 2.0.2
20348  */
20349  template<class ValueType, typename std::enable_if<
20351  ValueType value(const json_pointer& ptr, const ValueType& default_value) const
20352  {
20353  // at only works for objects
20354  if (JSON_HEDLEY_LIKELY(is_object()))
20355  {
20356  // if pointer resolves a value, return it or use default value
20357  JSON_TRY
20358  {
20359  return ptr.get_checked(this).template get<ValueType>();
20360  }
20361  JSON_INTERNAL_CATCH (out_of_range&)
20362  {
20363  return default_value;
20364  }
20365  }
20366 
20367  JSON_THROW(type_error::create(306, "cannot use value() with " + std::string(type_name())));
20368  }
20369 
20370  /*!
20371  @brief overload for a default value of type const char*
20372  @copydoc basic_json::value(const json_pointer&, ValueType) const
20373  */
20374  JSON_HEDLEY_NON_NULL(3)
20375  string_t value(const json_pointer& ptr, const char* default_value) const
20376  {
20377  return value(ptr, string_t(default_value));
20378  }
20379 
20380  /*!
20381  @brief access the first element
20382 
20383  Returns a reference to the first element in the container. For a JSON
20384  container `c`, the expression `c.front()` is equivalent to `*c.begin()`.
20385 
20386  @return In case of a structured type (array or object), a reference to the
20387  first element is returned. In case of number, string, boolean, or binary
20388  values, a reference to the value is returned.
20389 
20390  @complexity Constant.
20391 
20392  @pre The JSON value must not be `null` (would throw `std::out_of_range`)
20393  or an empty array or object (undefined behavior, **guarded by
20394  assertions**).
20395  @post The JSON value remains unchanged.
20396 
20397  @throw invalid_iterator.214 when called on `null` value
20398 
20399  @liveexample{The following code shows an example for `front()`.,front}
20400 
20401  @sa @ref back() -- access the last element
20402 
20403  @since version 1.0.0
20404  */
20406  {
20407  return *begin();
20408  }
20409 
20410  /*!
20411  @copydoc basic_json::front()
20412  */
20414  {
20415  return *cbegin();
20416  }
20417 
20418  /*!
20419  @brief access the last element
20420 
20421  Returns a reference to the last element in the container. For a JSON
20422  container `c`, the expression `c.back()` is equivalent to
20423  @code {.cpp}
20424  auto tmp = c.end();
20425  --tmp;
20426  return *tmp;
20427  @endcode
20428 
20429  @return In case of a structured type (array or object), a reference to the
20430  last element is returned. In case of number, string, boolean, or binary
20431  values, a reference to the value is returned.
20432 
20433  @complexity Constant.
20434 
20435  @pre The JSON value must not be `null` (would throw `std::out_of_range`)
20436  or an empty array or object (undefined behavior, **guarded by
20437  assertions**).
20438  @post The JSON value remains unchanged.
20439 
20440  @throw invalid_iterator.214 when called on a `null` value. See example
20441  below.
20442 
20443  @liveexample{The following code shows an example for `back()`.,back}
20444 
20445  @sa @ref front() -- access the first element
20446 
20447  @since version 1.0.0
20448  */
20450  {
20451  auto tmp = end();
20452  --tmp;
20453  return *tmp;
20454  }
20455 
20456  /*!
20457  @copydoc basic_json::back()
20458  */
20460  {
20461  auto tmp = cend();
20462  --tmp;
20463  return *tmp;
20464  }
20465 
20466  /*!
20467  @brief remove element given an iterator
20468 
20469  Removes the element specified by iterator @a pos. The iterator @a pos must
20470  be valid and dereferenceable. Thus the `end()` iterator (which is valid,
20471  but is not dereferenceable) cannot be used as a value for @a pos.
20472 
20473  If called on a primitive type other than `null`, the resulting JSON value
20474  will be `null`.
20475 
20476  @param[in] pos iterator to the element to remove
20477  @return Iterator following the last removed element. If the iterator @a
20478  pos refers to the last element, the `end()` iterator is returned.
20479 
20480  @tparam IteratorType an @ref iterator or @ref const_iterator
20481 
20482  @post Invalidates iterators and references at or after the point of the
20483  erase, including the `end()` iterator.
20484 
20485  @throw type_error.307 if called on a `null` value; example: `"cannot use
20486  erase() with null"`
20487  @throw invalid_iterator.202 if called on an iterator which does not belong
20488  to the current JSON value; example: `"iterator does not fit current
20489  value"`
20490  @throw invalid_iterator.205 if called on a primitive type with invalid
20491  iterator (i.e., any iterator which is not `begin()`); example: `"iterator
20492  out of range"`
20493 
20494  @complexity The complexity depends on the type:
20495  - objects: amortized constant
20496  - arrays: linear in distance between @a pos and the end of the container
20497  - strings and binary: linear in the length of the member
20498  - other types: constant
20499 
20500  @liveexample{The example shows the result of `erase()` for different JSON
20501  types.,erase__IteratorType}
20502 
20503  @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
20504  the given range
20505  @sa @ref erase(const typename object_t::key_type&) -- removes the element
20506  from an object at the given key
20507  @sa @ref erase(const size_type) -- removes the element from an array at
20508  the given index
20509 
20510  @since version 1.0.0
20511  */
20512  template < class IteratorType, typename std::enable_if <
20513  std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
20514  std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
20515  = 0 >
20516  IteratorType erase(IteratorType pos)
20517  {
20518  // make sure iterator fits the current value
20519  if (JSON_HEDLEY_UNLIKELY(this != pos.m_object))
20520  {
20521  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
20522  }
20523 
20524  IteratorType result = end();
20525 
20526  switch (m_type)
20527  {
20528  case value_t::boolean:
20529  case value_t::number_float:
20532  case value_t::string:
20533  case value_t::binary:
20534  {
20535  if (JSON_HEDLEY_UNLIKELY(!pos.m_it.primitive_iterator.is_begin()))
20536  {
20537  JSON_THROW(invalid_iterator::create(205, "iterator out of range"));
20538  }
20539 
20540  if (is_string())
20541  {
20542  AllocatorType<string_t> alloc;
20543  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
20544  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
20545  m_value.string = nullptr;
20546  }
20547  else if (is_binary())
20548  {
20549  AllocatorType<binary_t> alloc;
20550  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
20551  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
20552  m_value.binary = nullptr;
20553  }
20554 
20556  assert_invariant();
20557  break;
20558  }
20559 
20560  case value_t::object:
20561  {
20562  result.m_it.object_iterator = m_value.object->erase(pos.m_it.object_iterator);
20563  break;
20564  }
20565 
20566  case value_t::array:
20567  {
20568  result.m_it.array_iterator = m_value.array->erase(pos.m_it.array_iterator);
20569  break;
20570  }
20571 
20572  default:
20573  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
20574  }
20575 
20576  return result;
20577  }
20578 
20579  /*!
20580  @brief remove elements given an iterator range
20581 
20582  Removes the element specified by the range `[first; last)`. The iterator
20583  @a first does not need to be dereferenceable if `first == last`: erasing
20584  an empty range is a no-op.
20585 
20586  If called on a primitive type other than `null`, the resulting JSON value
20587  will be `null`.
20588 
20589  @param[in] first iterator to the beginning of the range to remove
20590  @param[in] last iterator past the end of the range to remove
20591  @return Iterator following the last removed element. If the iterator @a
20592  second refers to the last element, the `end()` iterator is returned.
20593 
20594  @tparam IteratorType an @ref iterator or @ref const_iterator
20595 
20596  @post Invalidates iterators and references at or after the point of the
20597  erase, including the `end()` iterator.
20598 
20599  @throw type_error.307 if called on a `null` value; example: `"cannot use
20600  erase() with null"`
20601  @throw invalid_iterator.203 if called on iterators which does not belong
20602  to the current JSON value; example: `"iterators do not fit current value"`
20603  @throw invalid_iterator.204 if called on a primitive type with invalid
20604  iterators (i.e., if `first != begin()` and `last != end()`); example:
20605  `"iterators out of range"`
20606 
20607  @complexity The complexity depends on the type:
20608  - objects: `log(size()) + std::distance(first, last)`
20609  - arrays: linear in the distance between @a first and @a last, plus linear
20610  in the distance between @a last and end of the container
20611  - strings and binary: linear in the length of the member
20612  - other types: constant
20613 
20614  @liveexample{The example shows the result of `erase()` for different JSON
20615  types.,erase__IteratorType_IteratorType}
20616 
20617  @sa @ref erase(IteratorType) -- removes the element at a given position
20618  @sa @ref erase(const typename object_t::key_type&) -- removes the element
20619  from an object at the given key
20620  @sa @ref erase(const size_type) -- removes the element from an array at
20621  the given index
20622 
20623  @since version 1.0.0
20624  */
20625  template < class IteratorType, typename std::enable_if <
20626  std::is_same<IteratorType, typename basic_json_t::iterator>::value ||
20627  std::is_same<IteratorType, typename basic_json_t::const_iterator>::value, int >::type
20628  = 0 >
20629  IteratorType erase(IteratorType first, IteratorType last)
20630  {
20631  // make sure iterator fits the current value
20632  if (JSON_HEDLEY_UNLIKELY(this != first.m_object || this != last.m_object))
20633  {
20634  JSON_THROW(invalid_iterator::create(203, "iterators do not fit current value"));
20635  }
20636 
20637  IteratorType result = end();
20638 
20639  switch (m_type)
20640  {
20641  case value_t::boolean:
20642  case value_t::number_float:
20645  case value_t::string:
20646  case value_t::binary:
20647  {
20648  if (JSON_HEDLEY_LIKELY(!first.m_it.primitive_iterator.is_begin()
20649  || !last.m_it.primitive_iterator.is_end()))
20650  {
20651  JSON_THROW(invalid_iterator::create(204, "iterators out of range"));
20652  }
20653 
20654  if (is_string())
20655  {
20656  AllocatorType<string_t> alloc;
20657  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.string);
20658  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.string, 1);
20659  m_value.string = nullptr;
20660  }
20661  else if (is_binary())
20662  {
20663  AllocatorType<binary_t> alloc;
20664  std::allocator_traits<decltype(alloc)>::destroy(alloc, m_value.binary);
20665  std::allocator_traits<decltype(alloc)>::deallocate(alloc, m_value.binary, 1);
20666  m_value.binary = nullptr;
20667  }
20668 
20670  assert_invariant();
20671  break;
20672  }
20673 
20674  case value_t::object:
20675  {
20676  result.m_it.object_iterator = m_value.object->erase(first.m_it.object_iterator,
20677  last.m_it.object_iterator);
20678  break;
20679  }
20680 
20681  case value_t::array:
20682  {
20683  result.m_it.array_iterator = m_value.array->erase(first.m_it.array_iterator,
20684  last.m_it.array_iterator);
20685  break;
20686  }
20687 
20688  default:
20689  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
20690  }
20691 
20692  return result;
20693  }
20694 
20695  /*!
20696  @brief remove element from a JSON object given a key
20697 
20698  Removes elements from a JSON object with the key value @a key.
20699 
20700  @param[in] key value of the elements to remove
20701 
20702  @return Number of elements removed. If @a ObjectType is the default
20703  `std::map` type, the return value will always be `0` (@a key was not
20704  found) or `1` (@a key was found).
20705 
20706  @post References and iterators to the erased elements are invalidated.
20707  Other references and iterators are not affected.
20708 
20709  @throw type_error.307 when called on a type other than JSON object;
20710  example: `"cannot use erase() with null"`
20711 
20712  @complexity `log(size()) + count(key)`
20713 
20714  @liveexample{The example shows the effect of `erase()`.,erase__key_type}
20715 
20716  @sa @ref erase(IteratorType) -- removes the element at a given position
20717  @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
20718  the given range
20719  @sa @ref erase(const size_type) -- removes the element from an array at
20720  the given index
20721 
20722  @since version 1.0.0
20723  */
20724  size_type erase(const typename object_t::key_type& key)
20725  {
20726  // this erase only works for objects
20727  if (JSON_HEDLEY_LIKELY(is_object()))
20728  {
20729  return m_value.object->erase(key);
20730  }
20731 
20732  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
20733  }
20734 
20735  /*!
20736  @brief remove element from a JSON array given an index
20737 
20738  Removes element from a JSON array at the index @a idx.
20739 
20740  @param[in] idx index of the element to remove
20741 
20742  @throw type_error.307 when called on a type other than JSON object;
20743  example: `"cannot use erase() with null"`
20744  @throw out_of_range.401 when `idx >= size()`; example: `"array index 17
20745  is out of range"`
20746 
20747  @complexity Linear in distance between @a idx and the end of the container.
20748 
20749  @liveexample{The example shows the effect of `erase()`.,erase__size_type}
20750 
20751  @sa @ref erase(IteratorType) -- removes the element at a given position
20752  @sa @ref erase(IteratorType, IteratorType) -- removes the elements in
20753  the given range
20754  @sa @ref erase(const typename object_t::key_type&) -- removes the element
20755  from an object at the given key
20756 
20757  @since version 1.0.0
20758  */
20759  void erase(const size_type idx)
20760  {
20761  // this erase only works for arrays
20762  if (JSON_HEDLEY_LIKELY(is_array()))
20763  {
20764  if (JSON_HEDLEY_UNLIKELY(idx >= size()))
20765  {
20766  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
20767  }
20768 
20769  m_value.array->erase(m_value.array->begin() + static_cast<difference_type>(idx));
20770  }
20771  else
20772  {
20773  JSON_THROW(type_error::create(307, "cannot use erase() with " + std::string(type_name())));
20774  }
20775  }
20776 
20777  /// @}
20778 
20779 
20780  ////////////
20781  // lookup //
20782  ////////////
20783 
20784  /// @name lookup
20785  /// @{
20786 
20787  /*!
20788  @brief find an element in a JSON object
20789 
20790  Finds an element in a JSON object with key equivalent to @a key. If the
20791  element is not found or the JSON value is not an object, end() is
20792  returned.
20793 
20794  @note This method always returns @ref end() when executed on a JSON type
20795  that is not an object.
20796 
20797  @param[in] key key value of the element to search for.
20798 
20799  @return Iterator to an element with key equivalent to @a key. If no such
20800  element is found or the JSON value is not an object, past-the-end (see
20801  @ref end()) iterator is returned.
20802 
20803  @complexity Logarithmic in the size of the JSON object.
20804 
20805  @liveexample{The example shows how `find()` is used.,find__key_type}
20806 
20807  @sa @ref contains(KeyT&&) const -- checks whether a key exists
20808 
20809  @since version 1.0.0
20810  */
20811  template<typename KeyT>
20812  iterator find(KeyT&& key)
20813  {
20814  auto result = end();
20815 
20816  if (is_object())
20817  {
20818  result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
20819  }
20820 
20821  return result;
20822  }
20823 
20824  /*!
20825  @brief find an element in a JSON object
20826  @copydoc find(KeyT&&)
20827  */
20828  template<typename KeyT>
20829  const_iterator find(KeyT&& key) const
20830  {
20831  auto result = cend();
20832 
20833  if (is_object())
20834  {
20835  result.m_it.object_iterator = m_value.object->find(std::forward<KeyT>(key));
20836  }
20837 
20838  return result;
20839  }
20840 
20841  /*!
20842  @brief returns the number of occurrences of a key in a JSON object
20843 
20844  Returns the number of elements with key @a key. If ObjectType is the
20845  default `std::map` type, the return value will always be `0` (@a key was
20846  not found) or `1` (@a key was found).
20847 
20848  @note This method always returns `0` when executed on a JSON type that is
20849  not an object.
20850 
20851  @param[in] key key value of the element to count
20852 
20853  @return Number of elements with key @a key. If the JSON value is not an
20854  object, the return value will be `0`.
20855 
20856  @complexity Logarithmic in the size of the JSON object.
20857 
20858  @liveexample{The example shows how `count()` is used.,count}
20859 
20860  @since version 1.0.0
20861  */
20862  template<typename KeyT>
20863  size_type count(KeyT&& key) const
20864  {
20865  // return 0 for all nonobject types
20866  return is_object() ? m_value.object->count(std::forward<KeyT>(key)) : 0;
20867  }
20868 
20869  /*!
20870  @brief check the existence of an element in a JSON object
20871 
20872  Check whether an element exists in a JSON object with key equivalent to
20873  @a key. If the element is not found or the JSON value is not an object,
20874  false is returned.
20875 
20876  @note This method always returns false when executed on a JSON type
20877  that is not an object.
20878 
20879  @param[in] key key value to check its existence.
20880 
20881  @return true if an element with specified @a key exists. If no such
20882  element with such key is found or the JSON value is not an object,
20883  false is returned.
20884 
20885  @complexity Logarithmic in the size of the JSON object.
20886 
20887  @liveexample{The following code shows an example for `contains()`.,contains}
20888 
20889  @sa @ref find(KeyT&&) -- returns an iterator to an object element
20890  @sa @ref contains(const json_pointer&) const -- checks the existence for a JSON pointer
20891 
20892  @since version 3.6.0
20893  */
20894  template < typename KeyT, typename std::enable_if <
20895  !std::is_same<typename std::decay<KeyT>::type, json_pointer>::value, int >::type = 0 >
20896  bool contains(KeyT && key) const
20897  {
20898  return is_object() && m_value.object->find(std::forward<KeyT>(key)) != m_value.object->end();
20899  }
20900 
20901  /*!
20902  @brief check the existence of an element in a JSON object given a JSON pointer
20903 
20904  Check whether the given JSON pointer @a ptr can be resolved in the current
20905  JSON value.
20906 
20907  @note This method can be executed on any JSON value type.
20908 
20909  @param[in] ptr JSON pointer to check its existence.
20910 
20911  @return true if the JSON pointer can be resolved to a stored value, false
20912  otherwise.
20913 
20914  @post If `j.contains(ptr)` returns true, it is safe to call `j[ptr]`.
20915 
20916  @throw parse_error.106 if an array index begins with '0'
20917  @throw parse_error.109 if an array index was not a number
20918 
20919  @complexity Logarithmic in the size of the JSON object.
20920 
20921  @liveexample{The following code shows an example for `contains()`.,contains_json_pointer}
20922 
20923  @sa @ref contains(KeyT &&) const -- checks the existence of a key
20924 
20925  @since version 3.7.0
20926  */
20927  bool contains(const json_pointer& ptr) const
20928  {
20929  return ptr.contains(this);
20930  }
20931 
20932  /// @}
20933 
20934 
20935  ///////////////
20936  // iterators //
20937  ///////////////
20938 
20939  /// @name iterators
20940  /// @{
20941 
20942  /*!
20943  @brief returns an iterator to the first element
20944 
20945  Returns an iterator to the first element.
20946 
20947  @image html range-begin-end.svg "Illustration from cppreference.com"
20948 
20949  @return iterator to the first element
20950 
20951  @complexity Constant.
20952 
20953  @requirement This function helps `basic_json` satisfying the
20954  [Container](https://en.cppreference.com/w/cpp/named_req/Container)
20955  requirements:
20956  - The complexity is constant.
20957 
20958  @liveexample{The following code shows an example for `begin()`.,begin}
20959 
20960  @sa @ref cbegin() -- returns a const iterator to the beginning
20961  @sa @ref end() -- returns an iterator to the end
20962  @sa @ref cend() -- returns a const iterator to the end
20963 
20964  @since version 1.0.0
20965  */
20966  iterator begin() noexcept
20967  {
20968  iterator result(this);
20969  result.set_begin();
20970  return result;
20971  }
20972 
20973  /*!
20974  @copydoc basic_json::cbegin()
20975  */
20976  const_iterator begin() const noexcept
20977  {
20978  return cbegin();
20979  }
20980 
20981  /*!
20982  @brief returns a const iterator to the first element
20983 
20984  Returns a const iterator to the first element.
20985 
20986  @image html range-begin-end.svg "Illustration from cppreference.com"
20987 
20988  @return const iterator to the first element
20989 
20990  @complexity Constant.
20991 
20992  @requirement This function helps `basic_json` satisfying the
20993  [Container](https://en.cppreference.com/w/cpp/named_req/Container)
20994  requirements:
20995  - The complexity is constant.
20996  - Has the semantics of `const_cast<const basic_json&>(*this).begin()`.
20997 
20998  @liveexample{The following code shows an example for `cbegin()`.,cbegin}
20999 
21000  @sa @ref begin() -- returns an iterator to the beginning
21001  @sa @ref end() -- returns an iterator to the end
21002  @sa @ref cend() -- returns a const iterator to the end
21003 
21004  @since version 1.0.0
21005  */
21006  const_iterator cbegin() const noexcept
21007  {
21008  const_iterator result(this);
21009  result.set_begin();
21010  return result;
21011  }
21012 
21013  /*!
21014  @brief returns an iterator to one past the last element
21015 
21016  Returns an iterator to one past the last element.
21017 
21018  @image html range-begin-end.svg "Illustration from cppreference.com"
21019 
21020  @return iterator one past the last element
21021 
21022  @complexity Constant.
21023 
21024  @requirement This function helps `basic_json` satisfying the
21025  [Container](https://en.cppreference.com/w/cpp/named_req/Container)
21026  requirements:
21027  - The complexity is constant.
21028 
21029  @liveexample{The following code shows an example for `end()`.,end}
21030 
21031  @sa @ref cend() -- returns a const iterator to the end
21032  @sa @ref begin() -- returns an iterator to the beginning
21033  @sa @ref cbegin() -- returns a const iterator to the beginning
21034 
21035  @since version 1.0.0
21036  */
21037  iterator end() noexcept
21038  {
21039  iterator result(this);
21040  result.set_end();
21041  return result;
21042  }
21043 
21044  /*!
21045  @copydoc basic_json::cend()
21046  */
21047  const_iterator end() const noexcept
21048  {
21049  return cend();
21050  }
21051 
21052  /*!
21053  @brief returns a const iterator to one past the last element
21054 
21055  Returns a const iterator to one past the last element.
21056 
21057  @image html range-begin-end.svg "Illustration from cppreference.com"
21058 
21059  @return const iterator one past the last element
21060 
21061  @complexity Constant.
21062 
21063  @requirement This function helps `basic_json` satisfying the
21064  [Container](https://en.cppreference.com/w/cpp/named_req/Container)
21065  requirements:
21066  - The complexity is constant.
21067  - Has the semantics of `const_cast<const basic_json&>(*this).end()`.
21068 
21069  @liveexample{The following code shows an example for `cend()`.,cend}
21070 
21071  @sa @ref end() -- returns an iterator to the end
21072  @sa @ref begin() -- returns an iterator to the beginning
21073  @sa @ref cbegin() -- returns a const iterator to the beginning
21074 
21075  @since version 1.0.0
21076  */
21077  const_iterator cend() const noexcept
21078  {
21079  const_iterator result(this);
21080  result.set_end();
21081  return result;
21082  }
21083 
21084  /*!
21085  @brief returns an iterator to the reverse-beginning
21086 
21087  Returns an iterator to the reverse-beginning; that is, the last element.
21088 
21089  @image html range-rbegin-rend.svg "Illustration from cppreference.com"
21090 
21091  @complexity Constant.
21092 
21093  @requirement This function helps `basic_json` satisfying the
21094  [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
21095  requirements:
21096  - The complexity is constant.
21097  - Has the semantics of `reverse_iterator(end())`.
21098 
21099  @liveexample{The following code shows an example for `rbegin()`.,rbegin}
21100 
21101  @sa @ref crbegin() -- returns a const reverse iterator to the beginning
21102  @sa @ref rend() -- returns a reverse iterator to the end
21103  @sa @ref crend() -- returns a const reverse iterator to the end
21104 
21105  @since version 1.0.0
21106  */
21108  {
21109  return reverse_iterator(end());
21110  }
21111 
21112  /*!
21113  @copydoc basic_json::crbegin()
21114  */
21116  {
21117  return crbegin();
21118  }
21119 
21120  /*!
21121  @brief returns an iterator to the reverse-end
21122 
21123  Returns an iterator to the reverse-end; that is, one before the first
21124  element.
21125 
21126  @image html range-rbegin-rend.svg "Illustration from cppreference.com"
21127 
21128  @complexity Constant.
21129 
21130  @requirement This function helps `basic_json` satisfying the
21131  [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
21132  requirements:
21133  - The complexity is constant.
21134  - Has the semantics of `reverse_iterator(begin())`.
21135 
21136  @liveexample{The following code shows an example for `rend()`.,rend}
21137 
21138  @sa @ref crend() -- returns a const reverse iterator to the end
21139  @sa @ref rbegin() -- returns a reverse iterator to the beginning
21140  @sa @ref crbegin() -- returns a const reverse iterator to the beginning
21141 
21142  @since version 1.0.0
21143  */
21145  {
21146  return reverse_iterator(begin());
21147  }
21148 
21149  /*!
21150  @copydoc basic_json::crend()
21151  */
21152  const_reverse_iterator rend() const noexcept
21153  {
21154  return crend();
21155  }
21156 
21157  /*!
21158  @brief returns a const reverse iterator to the last element
21159 
21160  Returns a const iterator to the reverse-beginning; that is, the last
21161  element.
21162 
21163  @image html range-rbegin-rend.svg "Illustration from cppreference.com"
21164 
21165  @complexity Constant.
21166 
21167  @requirement This function helps `basic_json` satisfying the
21168  [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
21169  requirements:
21170  - The complexity is constant.
21171  - Has the semantics of `const_cast<const basic_json&>(*this).rbegin()`.
21172 
21173  @liveexample{The following code shows an example for `crbegin()`.,crbegin}
21174 
21175  @sa @ref rbegin() -- returns a reverse iterator to the beginning
21176  @sa @ref rend() -- returns a reverse iterator to the end
21177  @sa @ref crend() -- returns a const reverse iterator to the end
21178 
21179  @since version 1.0.0
21180  */
21182  {
21183  return const_reverse_iterator(cend());
21184  }
21185 
21186  /*!
21187  @brief returns a const reverse iterator to one before the first
21188 
21189  Returns a const reverse iterator to the reverse-end; that is, one before
21190  the first element.
21191 
21192  @image html range-rbegin-rend.svg "Illustration from cppreference.com"
21193 
21194  @complexity Constant.
21195 
21196  @requirement This function helps `basic_json` satisfying the
21197  [ReversibleContainer](https://en.cppreference.com/w/cpp/named_req/ReversibleContainer)
21198  requirements:
21199  - The complexity is constant.
21200  - Has the semantics of `const_cast<const basic_json&>(*this).rend()`.
21201 
21202  @liveexample{The following code shows an example for `crend()`.,crend}
21203 
21204  @sa @ref rend() -- returns a reverse iterator to the end
21205  @sa @ref rbegin() -- returns a reverse iterator to the beginning
21206  @sa @ref crbegin() -- returns a const reverse iterator to the beginning
21207 
21208  @since version 1.0.0
21209  */
21211  {
21212  return const_reverse_iterator(cbegin());
21213  }
21214 
21215  public:
21216  /*!
21217  @brief wrapper to access iterator member functions in range-based for
21218 
21219  This function allows to access @ref iterator::key() and @ref
21220  iterator::value() during range-based for loops. In these loops, a
21221  reference to the JSON values is returned, so there is no access to the
21222  underlying iterator.
21223 
21224  For loop without iterator_wrapper:
21225 
21226  @code{cpp}
21227  for (auto it = j_object.begin(); it != j_object.end(); ++it)
21228  {
21229  std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
21230  }
21231  @endcode
21232 
21233  Range-based for loop without iterator proxy:
21234 
21235  @code{cpp}
21236  for (auto it : j_object)
21237  {
21238  // "it" is of type json::reference and has no key() member
21239  std::cout << "value: " << it << '\n';
21240  }
21241  @endcode
21242 
21243  Range-based for loop with iterator proxy:
21244 
21245  @code{cpp}
21246  for (auto it : json::iterator_wrapper(j_object))
21247  {
21248  std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
21249  }
21250  @endcode
21251 
21252  @note When iterating over an array, `key()` will return the index of the
21253  element as string (see example).
21254 
21255  @param[in] ref reference to a JSON value
21256  @return iteration proxy object wrapping @a ref with an interface to use in
21257  range-based for loops
21258 
21259  @liveexample{The following code shows how the wrapper is used,iterator_wrapper}
21260 
21261  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
21262  changes in the JSON value.
21263 
21264  @complexity Constant.
21265 
21266  @note The name of this function is not yet final and may change in the
21267  future.
21268 
21269  @deprecated This stream operator is deprecated and will be removed in
21270  future 4.0.0 of the library. Please use @ref items() instead;
21271  that is, replace `json::iterator_wrapper(j)` with `j.items()`.
21272  */
21273  JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
21275  {
21276  return ref.items();
21277  }
21278 
21279  /*!
21280  @copydoc iterator_wrapper(reference)
21281  */
21282  JSON_HEDLEY_DEPRECATED_FOR(3.1.0, items())
21284  {
21285  return ref.items();
21286  }
21287 
21288  /*!
21289  @brief helper to access iterator member functions in range-based for
21290 
21291  This function allows to access @ref iterator::key() and @ref
21292  iterator::value() during range-based for loops. In these loops, a
21293  reference to the JSON values is returned, so there is no access to the
21294  underlying iterator.
21295 
21296  For loop without `items()` function:
21297 
21298  @code{cpp}
21299  for (auto it = j_object.begin(); it != j_object.end(); ++it)
21300  {
21301  std::cout << "key: " << it.key() << ", value:" << it.value() << '\n';
21302  }
21303  @endcode
21304 
21305  Range-based for loop without `items()` function:
21306 
21307  @code{cpp}
21308  for (auto it : j_object)
21309  {
21310  // "it" is of type json::reference and has no key() member
21311  std::cout << "value: " << it << '\n';
21312  }
21313  @endcode
21314 
21315  Range-based for loop with `items()` function:
21316 
21317  @code{cpp}
21318  for (auto& el : j_object.items())
21319  {
21320  std::cout << "key: " << el.key() << ", value:" << el.value() << '\n';
21321  }
21322  @endcode
21323 
21324  The `items()` function also allows to use
21325  [structured bindings](https://en.cppreference.com/w/cpp/language/structured_binding)
21326  (C++17):
21327 
21328  @code{cpp}
21329  for (auto& [key, val] : j_object.items())
21330  {
21331  std::cout << "key: " << key << ", value:" << val << '\n';
21332  }
21333  @endcode
21334 
21335  @note When iterating over an array, `key()` will return the index of the
21336  element as string (see example). For primitive types (e.g., numbers),
21337  `key()` returns an empty string.
21338 
21339  @warning Using `items()` on temporary objects is dangerous. Make sure the
21340  object's lifetime exeeds the iteration. See
21341  <https://github.com/nlohmann/json/issues/2040> for more
21342  information.
21343 
21344  @return iteration proxy object wrapping @a ref with an interface to use in
21345  range-based for loops
21346 
21347  @liveexample{The following code shows how the function is used.,items}
21348 
21349  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
21350  changes in the JSON value.
21351 
21352  @complexity Constant.
21353 
21354  @since version 3.1.0, structured bindings support since 3.5.0.
21355  */
21357  {
21358  return iteration_proxy<iterator>(*this);
21359  }
21360 
21361  /*!
21362  @copydoc items()
21363  */
21365  {
21366  return iteration_proxy<const_iterator>(*this);
21367  }
21368 
21369  /// @}
21370 
21371 
21372  //////////////
21373  // capacity //
21374  //////////////
21375 
21376  /// @name capacity
21377  /// @{
21378 
21379  /*!
21380  @brief checks whether the container is empty.
21381 
21382  Checks if a JSON value has no elements (i.e. whether its @ref size is `0`).
21383 
21384  @return The return value depends on the different types and is
21385  defined as follows:
21386  Value type | return value
21387  ----------- | -------------
21388  null | `true`
21389  boolean | `false`
21390  string | `false`
21391  number | `false`
21392  binary | `false`
21393  object | result of function `object_t::empty()`
21394  array | result of function `array_t::empty()`
21395 
21396  @liveexample{The following code uses `empty()` to check if a JSON
21397  object contains any elements.,empty}
21398 
21399  @complexity Constant, as long as @ref array_t and @ref object_t satisfy
21400  the Container concept; that is, their `empty()` functions have constant
21401  complexity.
21402 
21403  @iterators No changes.
21404 
21405  @exceptionsafety No-throw guarantee: this function never throws exceptions.
21406 
21407  @note This function does not return whether a string stored as JSON value
21408  is empty - it returns whether the JSON container itself is empty which is
21409  false in the case of a string.
21410 
21411  @requirement This function helps `basic_json` satisfying the
21412  [Container](https://en.cppreference.com/w/cpp/named_req/Container)
21413  requirements:
21414  - The complexity is constant.
21415  - Has the semantics of `begin() == end()`.
21416 
21417  @sa @ref size() -- returns the number of elements
21418 
21419  @since version 1.0.0
21420  */
21421  bool empty() const noexcept
21422  {
21423  switch (m_type)
21424  {
21425  case value_t::null:
21426  {
21427  // null values are empty
21428  return true;
21429  }
21430 
21431  case value_t::array:
21432  {
21433  // delegate call to array_t::empty()
21434  return m_value.array->empty();
21435  }
21436 
21437  case value_t::object:
21438  {
21439  // delegate call to object_t::empty()
21440  return m_value.object->empty();
21441  }
21442 
21443  default:
21444  {
21445  // all other types are nonempty
21446  return false;
21447  }
21448  }
21449  }
21450 
21451  /*!
21452  @brief returns the number of elements
21453 
21454  Returns the number of elements in a JSON value.
21455 
21456  @return The return value depends on the different types and is
21457  defined as follows:
21458  Value type | return value
21459  ----------- | -------------
21460  null | `0`
21461  boolean | `1`
21462  string | `1`
21463  number | `1`
21464  binary | `1`
21465  object | result of function object_t::size()
21466  array | result of function array_t::size()
21467 
21468  @liveexample{The following code calls `size()` on the different value
21469  types.,size}
21470 
21471  @complexity Constant, as long as @ref array_t and @ref object_t satisfy
21472  the Container concept; that is, their size() functions have constant
21473  complexity.
21474 
21475  @iterators No changes.
21476 
21477  @exceptionsafety No-throw guarantee: this function never throws exceptions.
21478 
21479  @note This function does not return the length of a string stored as JSON
21480  value - it returns the number of elements in the JSON value which is 1 in
21481  the case of a string.
21482 
21483  @requirement This function helps `basic_json` satisfying the
21484  [Container](https://en.cppreference.com/w/cpp/named_req/Container)
21485  requirements:
21486  - The complexity is constant.
21487  - Has the semantics of `std::distance(begin(), end())`.
21488 
21489  @sa @ref empty() -- checks whether the container is empty
21490  @sa @ref max_size() -- returns the maximal number of elements
21491 
21492  @since version 1.0.0
21493  */
21494  size_type size() const noexcept
21495  {
21496  switch (m_type)
21497  {
21498  case value_t::null:
21499  {
21500  // null values are empty
21501  return 0;
21502  }
21503 
21504  case value_t::array:
21505  {
21506  // delegate call to array_t::size()
21507  return m_value.array->size();
21508  }
21509 
21510  case value_t::object:
21511  {
21512  // delegate call to object_t::size()
21513  return m_value.object->size();
21514  }
21515 
21516  default:
21517  {
21518  // all other types have size 1
21519  return 1;
21520  }
21521  }
21522  }
21523 
21524  /*!
21525  @brief returns the maximum possible number of elements
21526 
21527  Returns the maximum number of elements a JSON value is able to hold due to
21528  system or library implementation limitations, i.e. `std::distance(begin(),
21529  end())` for the JSON value.
21530 
21531  @return The return value depends on the different types and is
21532  defined as follows:
21533  Value type | return value
21534  ----------- | -------------
21535  null | `0` (same as `size()`)
21536  boolean | `1` (same as `size()`)
21537  string | `1` (same as `size()`)
21538  number | `1` (same as `size()`)
21539  binary | `1` (same as `size()`)
21540  object | result of function `object_t::max_size()`
21541  array | result of function `array_t::max_size()`
21542 
21543  @liveexample{The following code calls `max_size()` on the different value
21544  types. Note the output is implementation specific.,max_size}
21545 
21546  @complexity Constant, as long as @ref array_t and @ref object_t satisfy
21547  the Container concept; that is, their `max_size()` functions have constant
21548  complexity.
21549 
21550  @iterators No changes.
21551 
21552  @exceptionsafety No-throw guarantee: this function never throws exceptions.
21553 
21554  @requirement This function helps `basic_json` satisfying the
21555  [Container](https://en.cppreference.com/w/cpp/named_req/Container)
21556  requirements:
21557  - The complexity is constant.
21558  - Has the semantics of returning `b.size()` where `b` is the largest
21559  possible JSON value.
21560 
21561  @sa @ref size() -- returns the number of elements
21562 
21563  @since version 1.0.0
21564  */
21565  size_type max_size() const noexcept
21566  {
21567  switch (m_type)
21568  {
21569  case value_t::array:
21570  {
21571  // delegate call to array_t::max_size()
21572  return m_value.array->max_size();
21573  }
21574 
21575  case value_t::object:
21576  {
21577  // delegate call to object_t::max_size()
21578  return m_value.object->max_size();
21579  }
21580 
21581  default:
21582  {
21583  // all other types have max_size() == size()
21584  return size();
21585  }
21586  }
21587  }
21588 
21589  /// @}
21590 
21591 
21592  ///////////////
21593  // modifiers //
21594  ///////////////
21595 
21596  /// @name modifiers
21597  /// @{
21598 
21599  /*!
21600  @brief clears the contents
21601 
21602  Clears the content of a JSON value and resets it to the default value as
21603  if @ref basic_json(value_t) would have been called with the current value
21604  type from @ref type():
21605 
21606  Value type | initial value
21607  ----------- | -------------
21608  null | `null`
21609  boolean | `false`
21610  string | `""`
21611  number | `0`
21612  binary | An empty byte vector
21613  object | `{}`
21614  array | `[]`
21615 
21616  @post Has the same effect as calling
21617  @code {.cpp}
21618  *this = basic_json(type());
21619  @endcode
21620 
21621  @liveexample{The example below shows the effect of `clear()` to different
21622  JSON types.,clear}
21623 
21624  @complexity Linear in the size of the JSON value.
21625 
21626  @iterators All iterators, pointers and references related to this container
21627  are invalidated.
21628 
21629  @exceptionsafety No-throw guarantee: this function never throws exceptions.
21630 
21631  @sa @ref basic_json(value_t) -- constructor that creates an object with the
21632  same value than calling `clear()`
21633 
21634  @since version 1.0.0
21635  */
21636  void clear() noexcept
21637  {
21638  switch (m_type)
21639  {
21641  {
21642  m_value.number_integer = 0;
21643  break;
21644  }
21645 
21647  {
21649  break;
21650  }
21651 
21652  case value_t::number_float:
21653  {
21654  m_value.number_float = 0.0;
21655  break;
21656  }
21657 
21658  case value_t::boolean:
21659  {
21660  m_value.boolean = false;
21661  break;
21662  }
21663 
21664  case value_t::string:
21665  {
21666  m_value.string->clear();
21667  break;
21668  }
21669 
21670  case value_t::binary:
21671  {
21672  m_value.binary->clear();
21673  break;
21674  }
21675 
21676  case value_t::array:
21677  {
21678  m_value.array->clear();
21679  break;
21680  }
21681 
21682  case value_t::object:
21683  {
21684  m_value.object->clear();
21685  break;
21686  }
21687 
21688  default:
21689  break;
21690  }
21691  }
21692 
21693  /*!
21694  @brief add an object to an array
21695 
21696  Appends the given element @a val to the end of the JSON value. If the
21697  function is called on a JSON null value, an empty array is created before
21698  appending @a val.
21699 
21700  @param[in] val the value to add to the JSON array
21701 
21702  @throw type_error.308 when called on a type other than JSON array or
21703  null; example: `"cannot use push_back() with number"`
21704 
21705  @complexity Amortized constant.
21706 
21707  @liveexample{The example shows how `push_back()` and `+=` can be used to
21708  add elements to a JSON array. Note how the `null` value was silently
21709  converted to a JSON array.,push_back}
21710 
21711  @since version 1.0.0
21712  */
21713  void push_back(basic_json&& val)
21714  {
21715  // push_back only works for null objects or arrays
21716  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
21717  {
21718  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
21719  }
21720 
21721  // transform null object into an array
21722  if (is_null())
21723  {
21726  assert_invariant();
21727  }
21728 
21729  // add element to array (move semantics)
21730  m_value.array->push_back(std::move(val));
21731  // if val is moved from, basic_json move constructor marks it null so we do not call the destructor
21732  }
21733 
21734  /*!
21735  @brief add an object to an array
21736  @copydoc push_back(basic_json&&)
21737  */
21739  {
21740  push_back(std::move(val));
21741  return *this;
21742  }
21743 
21744  /*!
21745  @brief add an object to an array
21746  @copydoc push_back(basic_json&&)
21747  */
21748  void push_back(const basic_json& val)
21749  {
21750  // push_back only works for null objects or arrays
21751  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
21752  {
21753  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
21754  }
21755 
21756  // transform null object into an array
21757  if (is_null())
21758  {
21761  assert_invariant();
21762  }
21763 
21764  // add element to array
21765  m_value.array->push_back(val);
21766  }
21767 
21768  /*!
21769  @brief add an object to an array
21770  @copydoc push_back(basic_json&&)
21771  */
21773  {
21774  push_back(val);
21775  return *this;
21776  }
21777 
21778  /*!
21779  @brief add an object to an object
21780 
21781  Inserts the given element @a val to the JSON object. If the function is
21782  called on a JSON null value, an empty object is created before inserting
21783  @a val.
21784 
21785  @param[in] val the value to add to the JSON object
21786 
21787  @throw type_error.308 when called on a type other than JSON object or
21788  null; example: `"cannot use push_back() with number"`
21789 
21790  @complexity Logarithmic in the size of the container, O(log(`size()`)).
21791 
21792  @liveexample{The example shows how `push_back()` and `+=` can be used to
21793  add elements to a JSON object. Note how the `null` value was silently
21794  converted to a JSON object.,push_back__object_t__value}
21795 
21796  @since version 1.0.0
21797  */
21798  void push_back(const typename object_t::value_type& val)
21799  {
21800  // push_back only works for null objects or objects
21801  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
21802  {
21803  JSON_THROW(type_error::create(308, "cannot use push_back() with " + std::string(type_name())));
21804  }
21805 
21806  // transform null object into an object
21807  if (is_null())
21808  {
21811  assert_invariant();
21812  }
21813 
21814  // add element to array
21815  m_value.object->insert(val);
21816  }
21817 
21818  /*!
21819  @brief add an object to an object
21820  @copydoc push_back(const typename object_t::value_type&)
21821  */
21822  reference operator+=(const typename object_t::value_type& val)
21823  {
21824  push_back(val);
21825  return *this;
21826  }
21827 
21828  /*!
21829  @brief add an object to an object
21830 
21831  This function allows to use `push_back` with an initializer list. In case
21832 
21833  1. the current value is an object,
21834  2. the initializer list @a init contains only two elements, and
21835  3. the first element of @a init is a string,
21836 
21837  @a init is converted into an object element and added using
21838  @ref push_back(const typename object_t::value_type&). Otherwise, @a init
21839  is converted to a JSON value and added using @ref push_back(basic_json&&).
21840 
21841  @param[in] init an initializer list
21842 
21843  @complexity Linear in the size of the initializer list @a init.
21844 
21845  @note This function is required to resolve an ambiguous overload error,
21846  because pairs like `{"key", "value"}` can be both interpreted as
21847  `object_t::value_type` or `std::initializer_list<basic_json>`, see
21848  https://github.com/nlohmann/json/issues/235 for more information.
21849 
21850  @liveexample{The example shows how initializer lists are treated as
21851  objects when possible.,push_back__initializer_list}
21852  */
21854  {
21855  if (is_object() && init.size() == 2 && (*init.begin())->is_string())
21856  {
21857  basic_json&& key = init.begin()->moved_or_copied();
21858  push_back(typename object_t::value_type(
21859  std::move(key.get_ref<string_t&>()), (init.begin() + 1)->moved_or_copied()));
21860  }
21861  else
21862  {
21863  push_back(basic_json(init));
21864  }
21865  }
21866 
21867  /*!
21868  @brief add an object to an object
21869  @copydoc push_back(initializer_list_t)
21870  */
21872  {
21873  push_back(init);
21874  return *this;
21875  }
21876 
21877  /*!
21878  @brief add an object to an array
21879 
21880  Creates a JSON value from the passed parameters @a args to the end of the
21881  JSON value. If the function is called on a JSON null value, an empty array
21882  is created before appending the value created from @a args.
21883 
21884  @param[in] args arguments to forward to a constructor of @ref basic_json
21885  @tparam Args compatible types to create a @ref basic_json object
21886 
21887  @return reference to the inserted element
21888 
21889  @throw type_error.311 when called on a type other than JSON array or
21890  null; example: `"cannot use emplace_back() with number"`
21891 
21892  @complexity Amortized constant.
21893 
21894  @liveexample{The example shows how `push_back()` can be used to add
21895  elements to a JSON array. Note how the `null` value was silently converted
21896  to a JSON array.,emplace_back}
21897 
21898  @since version 2.0.8, returns reference since 3.7.0
21899  */
21900  template<class... Args>
21901  reference emplace_back(Args&& ... args)
21902  {
21903  // emplace_back only works for null objects or arrays
21904  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_array())))
21905  {
21906  JSON_THROW(type_error::create(311, "cannot use emplace_back() with " + std::string(type_name())));
21907  }
21908 
21909  // transform null object into an array
21910  if (is_null())
21911  {
21914  assert_invariant();
21915  }
21916 
21917  // add element to array (perfect forwarding)
21918 #ifdef JSON_HAS_CPP_17
21919  return m_value.array->emplace_back(std::forward<Args>(args)...);
21920 #else
21921  m_value.array->emplace_back(std::forward<Args>(args)...);
21922  return m_value.array->back();
21923 #endif
21924  }
21925 
21926  /*!
21927  @brief add an object to an object if key does not exist
21928 
21929  Inserts a new element into a JSON object constructed in-place with the
21930  given @a args if there is no element with the key in the container. If the
21931  function is called on a JSON null value, an empty object is created before
21932  appending the value created from @a args.
21933 
21934  @param[in] args arguments to forward to a constructor of @ref basic_json
21935  @tparam Args compatible types to create a @ref basic_json object
21936 
21937  @return a pair consisting of an iterator to the inserted element, or the
21938  already-existing element if no insertion happened, and a bool
21939  denoting whether the insertion took place.
21940 
21941  @throw type_error.311 when called on a type other than JSON object or
21942  null; example: `"cannot use emplace() with number"`
21943 
21944  @complexity Logarithmic in the size of the container, O(log(`size()`)).
21945 
21946  @liveexample{The example shows how `emplace()` can be used to add elements
21947  to a JSON object. Note how the `null` value was silently converted to a
21948  JSON object. Further note how no value is added if there was already one
21949  value stored with the same key.,emplace}
21950 
21951  @since version 2.0.8
21952  */
21953  template<class... Args>
21954  std::pair<iterator, bool> emplace(Args&& ... args)
21955  {
21956  // emplace only works for null objects or arrays
21957  if (JSON_HEDLEY_UNLIKELY(!(is_null() || is_object())))
21958  {
21959  JSON_THROW(type_error::create(311, "cannot use emplace() with " + std::string(type_name())));
21960  }
21961 
21962  // transform null object into an object
21963  if (is_null())
21964  {
21967  assert_invariant();
21968  }
21969 
21970  // add element to array (perfect forwarding)
21971  auto res = m_value.object->emplace(std::forward<Args>(args)...);
21972  // create result iterator and set iterator to the result of emplace
21973  auto it = begin();
21974  it.m_it.object_iterator = res.first;
21975 
21976  // return pair of iterator and boolean
21977  return {it, res.second};
21978  }
21979 
21980  /// Helper for insertion of an iterator
21981  /// @note: This uses std::distance to support GCC 4.8,
21982  /// see https://github.com/nlohmann/json/pull/1257
21983  template<typename... Args>
21985  {
21986  iterator result(this);
21987  JSON_ASSERT(m_value.array != nullptr);
21988 
21989  auto insert_pos = std::distance(m_value.array->begin(), pos.m_it.array_iterator);
21990  m_value.array->insert(pos.m_it.array_iterator, std::forward<Args>(args)...);
21991  result.m_it.array_iterator = m_value.array->begin() + insert_pos;
21992 
21993  // This could have been written as:
21994  // result.m_it.array_iterator = m_value.array->insert(pos.m_it.array_iterator, cnt, val);
21995  // but the return value of insert is missing in GCC 4.8, so it is written this way instead.
21996 
21997  return result;
21998  }
21999 
22000  /*!
22001  @brief inserts element
22002 
22003  Inserts element @a val before iterator @a pos.
22004 
22005  @param[in] pos iterator before which the content will be inserted; may be
22006  the end() iterator
22007  @param[in] val element to insert
22008  @return iterator pointing to the inserted @a val.
22009 
22010  @throw type_error.309 if called on JSON values other than arrays;
22011  example: `"cannot use insert() with string"`
22012  @throw invalid_iterator.202 if @a pos is not an iterator of *this;
22013  example: `"iterator does not fit current value"`
22014 
22015  @complexity Constant plus linear in the distance between @a pos and end of
22016  the container.
22017 
22018  @liveexample{The example shows how `insert()` is used.,insert}
22019 
22020  @since version 1.0.0
22021  */
22023  {
22024  // insert only works for arrays
22025  if (JSON_HEDLEY_LIKELY(is_array()))
22026  {
22027  // check if iterator pos fits to this JSON value
22028  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22029  {
22030  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
22031  }
22032 
22033  // insert to array and return iterator
22034  return insert_iterator(pos, val);
22035  }
22036 
22037  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
22038  }
22039 
22040  /*!
22041  @brief inserts element
22042  @copydoc insert(const_iterator, const basic_json&)
22043  */
22045  {
22046  return insert(pos, val);
22047  }
22048 
22049  /*!
22050  @brief inserts elements
22051 
22052  Inserts @a cnt copies of @a val before iterator @a pos.
22053 
22054  @param[in] pos iterator before which the content will be inserted; may be
22055  the end() iterator
22056  @param[in] cnt number of copies of @a val to insert
22057  @param[in] val element to insert
22058  @return iterator pointing to the first element inserted, or @a pos if
22059  `cnt==0`
22060 
22061  @throw type_error.309 if called on JSON values other than arrays; example:
22062  `"cannot use insert() with string"`
22063  @throw invalid_iterator.202 if @a pos is not an iterator of *this;
22064  example: `"iterator does not fit current value"`
22065 
22066  @complexity Linear in @a cnt plus linear in the distance between @a pos
22067  and end of the container.
22068 
22069  @liveexample{The example shows how `insert()` is used.,insert__count}
22070 
22071  @since version 1.0.0
22072  */
22074  {
22075  // insert only works for arrays
22076  if (JSON_HEDLEY_LIKELY(is_array()))
22077  {
22078  // check if iterator pos fits to this JSON value
22079  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22080  {
22081  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
22082  }
22083 
22084  // insert to array and return iterator
22085  return insert_iterator(pos, cnt, val);
22086  }
22087 
22088  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
22089  }
22090 
22091  /*!
22092  @brief inserts elements
22093 
22094  Inserts elements from range `[first, last)` before iterator @a pos.
22095 
22096  @param[in] pos iterator before which the content will be inserted; may be
22097  the end() iterator
22098  @param[in] first begin of the range of elements to insert
22099  @param[in] last end of the range of elements to insert
22100 
22101  @throw type_error.309 if called on JSON values other than arrays; example:
22102  `"cannot use insert() with string"`
22103  @throw invalid_iterator.202 if @a pos is not an iterator of *this;
22104  example: `"iterator does not fit current value"`
22105  @throw invalid_iterator.210 if @a first and @a last do not belong to the
22106  same JSON value; example: `"iterators do not fit"`
22107  @throw invalid_iterator.211 if @a first or @a last are iterators into
22108  container for which insert is called; example: `"passed iterators may not
22109  belong to container"`
22110 
22111  @return iterator pointing to the first element inserted, or @a pos if
22112  `first==last`
22113 
22114  @complexity Linear in `std::distance(first, last)` plus linear in the
22115  distance between @a pos and end of the container.
22116 
22117  @liveexample{The example shows how `insert()` is used.,insert__range}
22118 
22119  @since version 1.0.0
22120  */
22122  {
22123  // insert only works for arrays
22124  if (JSON_HEDLEY_UNLIKELY(!is_array()))
22125  {
22126  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
22127  }
22128 
22129  // check if iterator pos fits to this JSON value
22130  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22131  {
22132  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
22133  }
22134 
22135  // check if range iterators belong to the same JSON object
22136  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22137  {
22138  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
22139  }
22140 
22141  if (JSON_HEDLEY_UNLIKELY(first.m_object == this))
22142  {
22143  JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container"));
22144  }
22145 
22146  // insert to array and return iterator
22147  return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
22148  }
22149 
22150  /*!
22151  @brief inserts elements
22152 
22153  Inserts elements from initializer list @a ilist before iterator @a pos.
22154 
22155  @param[in] pos iterator before which the content will be inserted; may be
22156  the end() iterator
22157  @param[in] ilist initializer list to insert the values from
22158 
22159  @throw type_error.309 if called on JSON values other than arrays; example:
22160  `"cannot use insert() with string"`
22161  @throw invalid_iterator.202 if @a pos is not an iterator of *this;
22162  example: `"iterator does not fit current value"`
22163 
22164  @return iterator pointing to the first element inserted, or @a pos if
22165  `ilist` is empty
22166 
22167  @complexity Linear in `ilist.size()` plus linear in the distance between
22168  @a pos and end of the container.
22169 
22170  @liveexample{The example shows how `insert()` is used.,insert__ilist}
22171 
22172  @since version 1.0.0
22173  */
22175  {
22176  // insert only works for arrays
22177  if (JSON_HEDLEY_UNLIKELY(!is_array()))
22178  {
22179  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
22180  }
22181 
22182  // check if iterator pos fits to this JSON value
22183  if (JSON_HEDLEY_UNLIKELY(pos.m_object != this))
22184  {
22185  JSON_THROW(invalid_iterator::create(202, "iterator does not fit current value"));
22186  }
22187 
22188  // insert to array and return iterator
22189  return insert_iterator(pos, ilist.begin(), ilist.end());
22190  }
22191 
22192  /*!
22193  @brief inserts elements
22194 
22195  Inserts elements from range `[first, last)`.
22196 
22197  @param[in] first begin of the range of elements to insert
22198  @param[in] last end of the range of elements to insert
22199 
22200  @throw type_error.309 if called on JSON values other than objects; example:
22201  `"cannot use insert() with string"`
22202  @throw invalid_iterator.202 if iterator @a first or @a last does does not
22203  point to an object; example: `"iterators first and last must point to
22204  objects"`
22205  @throw invalid_iterator.210 if @a first and @a last do not belong to the
22206  same JSON value; example: `"iterators do not fit"`
22207 
22208  @complexity Logarithmic: `O(N*log(size() + N))`, where `N` is the number
22209  of elements to insert.
22210 
22211  @liveexample{The example shows how `insert()` is used.,insert__range_object}
22212 
22213  @since version 3.0.0
22214  */
22216  {
22217  // insert only works for objects
22218  if (JSON_HEDLEY_UNLIKELY(!is_object()))
22219  {
22220  JSON_THROW(type_error::create(309, "cannot use insert() with " + std::string(type_name())));
22221  }
22222 
22223  // check if range iterators belong to the same JSON object
22224  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22225  {
22226  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
22227  }
22228 
22229  // passed iterators must belong to objects
22230  if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()))
22231  {
22232  JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
22233  }
22234 
22235  m_value.object->insert(first.m_it.object_iterator, last.m_it.object_iterator);
22236  }
22237 
22238  /*!
22239  @brief updates a JSON object from another object, overwriting existing keys
22240 
22241  Inserts all values from JSON object @a j and overwrites existing keys.
22242 
22243  @param[in] j JSON object to read values from
22244 
22245  @throw type_error.312 if called on JSON values other than objects; example:
22246  `"cannot use update() with string"`
22247 
22248  @complexity O(N*log(size() + N)), where N is the number of elements to
22249  insert.
22250 
22251  @liveexample{The example shows how `update()` is used.,update}
22252 
22253  @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
22254 
22255  @since version 3.0.0
22256  */
22258  {
22259  // implicitly convert null value to an empty object
22260  if (is_null())
22261  {
22263  m_value.object = create<object_t>();
22264  assert_invariant();
22265  }
22266 
22267  if (JSON_HEDLEY_UNLIKELY(!is_object()))
22268  {
22269  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
22270  }
22271  if (JSON_HEDLEY_UNLIKELY(!j.is_object()))
22272  {
22273  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(j.type_name())));
22274  }
22275 
22276  for (auto it = j.cbegin(); it != j.cend(); ++it)
22277  {
22278  m_value.object->operator[](it.key()) = it.value();
22279  }
22280  }
22281 
22282  /*!
22283  @brief updates a JSON object from another object, overwriting existing keys
22284 
22285  Inserts all values from from range `[first, last)` and overwrites existing
22286  keys.
22287 
22288  @param[in] first begin of the range of elements to insert
22289  @param[in] last end of the range of elements to insert
22290 
22291  @throw type_error.312 if called on JSON values other than objects; example:
22292  `"cannot use update() with string"`
22293  @throw invalid_iterator.202 if iterator @a first or @a last does does not
22294  point to an object; example: `"iterators first and last must point to
22295  objects"`
22296  @throw invalid_iterator.210 if @a first and @a last do not belong to the
22297  same JSON value; example: `"iterators do not fit"`
22298 
22299  @complexity O(N*log(size() + N)), where N is the number of elements to
22300  insert.
22301 
22302  @liveexample{The example shows how `update()` is used__range.,update}
22303 
22304  @sa https://docs.python.org/3.6/library/stdtypes.html#dict.update
22305 
22306  @since version 3.0.0
22307  */
22309  {
22310  // implicitly convert null value to an empty object
22311  if (is_null())
22312  {
22314  m_value.object = create<object_t>();
22315  assert_invariant();
22316  }
22317 
22318  if (JSON_HEDLEY_UNLIKELY(!is_object()))
22319  {
22320  JSON_THROW(type_error::create(312, "cannot use update() with " + std::string(type_name())));
22321  }
22322 
22323  // check if range iterators belong to the same JSON object
22324  if (JSON_HEDLEY_UNLIKELY(first.m_object != last.m_object))
22325  {
22326  JSON_THROW(invalid_iterator::create(210, "iterators do not fit"));
22327  }
22328 
22329  // passed iterators must belong to objects
22330  if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_object()
22331  || !last.m_object->is_object()))
22332  {
22333  JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to objects"));
22334  }
22335 
22336  for (auto it = first; it != last; ++it)
22337  {
22338  m_value.object->operator[](it.key()) = it.value();
22339  }
22340  }
22341 
22342  /*!
22343  @brief exchanges the values
22344 
22345  Exchanges the contents of the JSON value with those of @a other. Does not
22346  invoke any move, copy, or swap operations on individual elements. All
22347  iterators and references remain valid. The past-the-end iterator is
22348  invalidated.
22349 
22350  @param[in,out] other JSON value to exchange the contents with
22351 
22352  @complexity Constant.
22353 
22354  @liveexample{The example below shows how JSON values can be swapped with
22355  `swap()`.,swap__reference}
22356 
22357  @since version 1.0.0
22358  */
22359  void swap(reference other) noexcept (
22360  std::is_nothrow_move_constructible<value_t>::value&&
22361  std::is_nothrow_move_assignable<value_t>::value&&
22362  std::is_nothrow_move_constructible<json_value>::value&&
22363  std::is_nothrow_move_assignable<json_value>::value
22364  )
22365  {
22366  std::swap(m_type, other.m_type);
22367  std::swap(m_value, other.m_value);
22368  assert_invariant();
22369  }
22370 
22371  /*!
22372  @brief exchanges the values
22373 
22374  Exchanges the contents of the JSON value from @a left with those of @a right. Does not
22375  invoke any move, copy, or swap operations on individual elements. All
22376  iterators and references remain valid. The past-the-end iterator is
22377  invalidated. implemented as a friend function callable via ADL.
22378 
22379  @param[in,out] left JSON value to exchange the contents with
22380  @param[in,out] right JSON value to exchange the contents with
22381 
22382  @complexity Constant.
22383 
22384  @liveexample{The example below shows how JSON values can be swapped with
22385  `swap()`.,swap__reference}
22386 
22387  @since version 1.0.0
22388  */
22389  friend void swap(reference left, reference right) noexcept (
22390  std::is_nothrow_move_constructible<value_t>::value&&
22391  std::is_nothrow_move_assignable<value_t>::value&&
22392  std::is_nothrow_move_constructible<json_value>::value&&
22393  std::is_nothrow_move_assignable<json_value>::value
22394  )
22395  {
22396  left.swap(right);
22397  }
22398 
22399  /*!
22400  @brief exchanges the values
22401 
22402  Exchanges the contents of a JSON array with those of @a other. Does not
22403  invoke any move, copy, or swap operations on individual elements. All
22404  iterators and references remain valid. The past-the-end iterator is
22405  invalidated.
22406 
22407  @param[in,out] other array to exchange the contents with
22408 
22409  @throw type_error.310 when JSON value is not an array; example: `"cannot
22410  use swap() with string"`
22411 
22412  @complexity Constant.
22413 
22414  @liveexample{The example below shows how arrays can be swapped with
22415  `swap()`.,swap__array_t}
22416 
22417  @since version 1.0.0
22418  */
22419  void swap(array_t& other)
22420  {
22421  // swap only works for arrays
22422  if (JSON_HEDLEY_LIKELY(is_array()))
22423  {
22424  std::swap(*(m_value.array), other);
22425  }
22426  else
22427  {
22428  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
22429  }
22430  }
22431 
22432  /*!
22433  @brief exchanges the values
22434 
22435  Exchanges the contents of a JSON object with those of @a other. Does not
22436  invoke any move, copy, or swap operations on individual elements. All
22437  iterators and references remain valid. The past-the-end iterator is
22438  invalidated.
22439 
22440  @param[in,out] other object to exchange the contents with
22441 
22442  @throw type_error.310 when JSON value is not an object; example:
22443  `"cannot use swap() with string"`
22444 
22445  @complexity Constant.
22446 
22447  @liveexample{The example below shows how objects can be swapped with
22448  `swap()`.,swap__object_t}
22449 
22450  @since version 1.0.0
22451  */
22452  void swap(object_t& other)
22453  {
22454  // swap only works for objects
22455  if (JSON_HEDLEY_LIKELY(is_object()))
22456  {
22457  std::swap(*(m_value.object), other);
22458  }
22459  else
22460  {
22461  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
22462  }
22463  }
22464 
22465  /*!
22466  @brief exchanges the values
22467 
22468  Exchanges the contents of a JSON string with those of @a other. Does not
22469  invoke any move, copy, or swap operations on individual elements. All
22470  iterators and references remain valid. The past-the-end iterator is
22471  invalidated.
22472 
22473  @param[in,out] other string to exchange the contents with
22474 
22475  @throw type_error.310 when JSON value is not a string; example: `"cannot
22476  use swap() with boolean"`
22477 
22478  @complexity Constant.
22479 
22480  @liveexample{The example below shows how strings can be swapped with
22481  `swap()`.,swap__string_t}
22482 
22483  @since version 1.0.0
22484  */
22485  void swap(string_t& other)
22486  {
22487  // swap only works for strings
22488  if (JSON_HEDLEY_LIKELY(is_string()))
22489  {
22490  std::swap(*(m_value.string), other);
22491  }
22492  else
22493  {
22494  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
22495  }
22496  }
22497 
22498  /*!
22499  @brief exchanges the values
22500 
22501  Exchanges the contents of a JSON string with those of @a other. Does not
22502  invoke any move, copy, or swap operations on individual elements. All
22503  iterators and references remain valid. The past-the-end iterator is
22504  invalidated.
22505 
22506  @param[in,out] other binary to exchange the contents with
22507 
22508  @throw type_error.310 when JSON value is not a string; example: `"cannot
22509  use swap() with boolean"`
22510 
22511  @complexity Constant.
22512 
22513  @liveexample{The example below shows how strings can be swapped with
22514  `swap()`.,swap__binary_t}
22515 
22516  @since version 3.8.0
22517  */
22518  void swap(binary_t& other)
22519  {
22520  // swap only works for strings
22521  if (JSON_HEDLEY_LIKELY(is_binary()))
22522  {
22523  std::swap(*(m_value.binary), other);
22524  }
22525  else
22526  {
22527  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
22528  }
22529  }
22530 
22531  /// @copydoc swap(binary_t)
22532  void swap(typename binary_t::container_type& other)
22533  {
22534  // swap only works for strings
22535  if (JSON_HEDLEY_LIKELY(is_binary()))
22536  {
22537  std::swap(*(m_value.binary), other);
22538  }
22539  else
22540  {
22541  JSON_THROW(type_error::create(310, "cannot use swap() with " + std::string(type_name())));
22542  }
22543  }
22544 
22545  /// @}
22546 
22547  public:
22548  //////////////////////////////////////////
22549  // lexicographical comparison operators //
22550  //////////////////////////////////////////
22551 
22552  /// @name lexicographical comparison operators
22553  /// @{
22554 
22555  /*!
22556  @brief comparison: equal
22557 
22558  Compares two JSON values for equality according to the following rules:
22559  - Two JSON values are equal if (1) they are from the same type and (2)
22560  their stored values are the same according to their respective
22561  `operator==`.
22562  - Integer and floating-point numbers are automatically converted before
22563  comparison. Note that two NaN values are always treated as unequal.
22564  - Two JSON null values are equal.
22565 
22566  @note Floating-point inside JSON values numbers are compared with
22567  `json::number_float_t::operator==` which is `double::operator==` by
22568  default. To compare floating-point while respecting an epsilon, an alternative
22569  [comparison function](https://github.com/mariokonrad/marnav/blob/master/include/marnav/math/floatingpoint.hpp#L34-#L39)
22570  could be used, for instance
22571  @code {.cpp}
22572  template<typename T, typename = typename std::enable_if<std::is_floating_point<T>::value, T>::type>
22573  inline bool is_same(T a, T b, T epsilon = std::numeric_limits<T>::epsilon()) noexcept
22574  {
22575  return std::abs(a - b) <= epsilon;
22576  }
22577  @endcode
22578  Or you can self-defined operator equal function like this:
22579  @code {.cpp}
22580  bool my_equal(const_reference lhs, const_reference rhs) {
22581  const auto lhs_type lhs.type();
22582  const auto rhs_type rhs.type();
22583  if (lhs_type == rhs_type) {
22584  switch(lhs_type)
22585  // self_defined case
22586  case value_t::number_float:
22587  return std::abs(lhs - rhs) <= std::numeric_limits<float>::epsilon();
22588  // other cases remain the same with the original
22589  ...
22590  }
22591  ...
22592  }
22593  @endcode
22594 
22595  @note NaN values never compare equal to themselves or to other NaN values.
22596 
22597  @param[in] lhs first JSON value to consider
22598  @param[in] rhs second JSON value to consider
22599  @return whether the values @a lhs and @a rhs are equal
22600 
22601  @exceptionsafety No-throw guarantee: this function never throws exceptions.
22602 
22603  @complexity Linear.
22604 
22605  @liveexample{The example demonstrates comparing several JSON
22606  types.,operator__equal}
22607 
22608  @since version 1.0.0
22609  */
22610  friend bool operator==(const_reference lhs, const_reference rhs) noexcept
22611  {
22612  const auto lhs_type = lhs.type();
22613  const auto rhs_type = rhs.type();
22614 
22615  if (lhs_type == rhs_type)
22616  {
22617  switch (lhs_type)
22618  {
22619  case value_t::array:
22620  return *lhs.m_value.array == *rhs.m_value.array;
22621 
22622  case value_t::object:
22623  return *lhs.m_value.object == *rhs.m_value.object;
22624 
22625  case value_t::null:
22626  return true;
22627 
22628  case value_t::string:
22629  return *lhs.m_value.string == *rhs.m_value.string;
22630 
22631  case value_t::boolean:
22632  return lhs.m_value.boolean == rhs.m_value.boolean;
22633 
22635  return lhs.m_value.number_integer == rhs.m_value.number_integer;
22636 
22638  return lhs.m_value.number_unsigned == rhs.m_value.number_unsigned;
22639 
22640  case value_t::number_float:
22641  return lhs.m_value.number_float == rhs.m_value.number_float;
22642 
22643  case value_t::binary:
22644  return *lhs.m_value.binary == *rhs.m_value.binary;
22645 
22646  default:
22647  return false;
22648  }
22649  }
22650  else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
22651  {
22652  return static_cast<number_float_t>(lhs.m_value.number_integer) == rhs.m_value.number_float;
22653  }
22654  else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
22655  {
22656  return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_integer);
22657  }
22658  else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
22659  {
22660  return static_cast<number_float_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_float;
22661  }
22662  else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
22663  {
22664  return lhs.m_value.number_float == static_cast<number_float_t>(rhs.m_value.number_unsigned);
22665  }
22666  else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
22667  {
22668  return static_cast<number_integer_t>(lhs.m_value.number_unsigned) == rhs.m_value.number_integer;
22669  }
22670  else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
22671  {
22672  return lhs.m_value.number_integer == static_cast<number_integer_t>(rhs.m_value.number_unsigned);
22673  }
22674 
22675  return false;
22676  }
22677 
22678  /*!
22679  @brief comparison: equal
22680  @copydoc operator==(const_reference, const_reference)
22681  */
22682  template<typename ScalarType, typename std::enable_if<
22683  std::is_scalar<ScalarType>::value, int>::type = 0>
22684  friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
22685  {
22686  return lhs == basic_json(rhs);
22687  }
22688 
22689  /*!
22690  @brief comparison: equal
22691  @copydoc operator==(const_reference, const_reference)
22692  */
22693  template<typename ScalarType, typename std::enable_if<
22694  std::is_scalar<ScalarType>::value, int>::type = 0>
22695  friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
22696  {
22697  return basic_json(lhs) == rhs;
22698  }
22699 
22700  /*!
22701  @brief comparison: not equal
22702 
22703  Compares two JSON values for inequality by calculating `not (lhs == rhs)`.
22704 
22705  @param[in] lhs first JSON value to consider
22706  @param[in] rhs second JSON value to consider
22707  @return whether the values @a lhs and @a rhs are not equal
22708 
22709  @complexity Linear.
22710 
22711  @exceptionsafety No-throw guarantee: this function never throws exceptions.
22712 
22713  @liveexample{The example demonstrates comparing several JSON
22714  types.,operator__notequal}
22715 
22716  @since version 1.0.0
22717  */
22718  friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
22719  {
22720  return !(lhs == rhs);
22721  }
22722 
22723  /*!
22724  @brief comparison: not equal
22725  @copydoc operator!=(const_reference, const_reference)
22726  */
22727  template<typename ScalarType, typename std::enable_if<
22728  std::is_scalar<ScalarType>::value, int>::type = 0>
22729  friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
22730  {
22731  return lhs != basic_json(rhs);
22732  }
22733 
22734  /*!
22735  @brief comparison: not equal
22736  @copydoc operator!=(const_reference, const_reference)
22737  */
22738  template<typename ScalarType, typename std::enable_if<
22739  std::is_scalar<ScalarType>::value, int>::type = 0>
22740  friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
22741  {
22742  return basic_json(lhs) != rhs;
22743  }
22744 
22745  /*!
22746  @brief comparison: less than
22747 
22748  Compares whether one JSON value @a lhs is less than another JSON value @a
22749  rhs according to the following rules:
22750  - If @a lhs and @a rhs have the same type, the values are compared using
22751  the default `<` operator.
22752  - Integer and floating-point numbers are automatically converted before
22753  comparison
22754  - In case @a lhs and @a rhs have different types, the values are ignored
22755  and the order of the types is considered, see
22756  @ref operator<(const value_t, const value_t).
22757 
22758  @param[in] lhs first JSON value to consider
22759  @param[in] rhs second JSON value to consider
22760  @return whether @a lhs is less than @a rhs
22761 
22762  @complexity Linear.
22763 
22764  @exceptionsafety No-throw guarantee: this function never throws exceptions.
22765 
22766  @liveexample{The example demonstrates comparing several JSON
22767  types.,operator__less}
22768 
22769  @since version 1.0.0
22770  */
22771  friend bool operator<(const_reference lhs, const_reference rhs) noexcept
22772  {
22773  const auto lhs_type = lhs.type();
22774  const auto rhs_type = rhs.type();
22775 
22776  if (lhs_type == rhs_type)
22777  {
22778  switch (lhs_type)
22779  {
22780  case value_t::array:
22781  // note parentheses are necessary, see
22782  // https://github.com/nlohmann/json/issues/1530
22783  return (*lhs.m_value.array) < (*rhs.m_value.array);
22784 
22785  case value_t::object:
22786  return (*lhs.m_value.object) < (*rhs.m_value.object);
22787 
22788  case value_t::null:
22789  return false;
22790 
22791  case value_t::string:
22792  return (*lhs.m_value.string) < (*rhs.m_value.string);
22793 
22794  case value_t::boolean:
22795  return (lhs.m_value.boolean) < (rhs.m_value.boolean);
22796 
22798  return (lhs.m_value.number_integer) < (rhs.m_value.number_integer);
22799 
22801  return (lhs.m_value.number_unsigned) < (rhs.m_value.number_unsigned);
22802 
22803  case value_t::number_float:
22804  return (lhs.m_value.number_float) < (rhs.m_value.number_float);
22805 
22806  case value_t::binary:
22807  return (*lhs.m_value.binary) < (*rhs.m_value.binary);
22808 
22809  default:
22810  return false;
22811  }
22812  }
22813  else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_float)
22814  {
22815  return static_cast<number_float_t>(lhs.m_value.number_integer) < rhs.m_value.number_float;
22816  }
22817  else if (lhs_type == value_t::number_float && rhs_type == value_t::number_integer)
22818  {
22819  return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_integer);
22820  }
22821  else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_float)
22822  {
22823  return static_cast<number_float_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_float;
22824  }
22825  else if (lhs_type == value_t::number_float && rhs_type == value_t::number_unsigned)
22826  {
22827  return lhs.m_value.number_float < static_cast<number_float_t>(rhs.m_value.number_unsigned);
22828  }
22829  else if (lhs_type == value_t::number_integer && rhs_type == value_t::number_unsigned)
22830  {
22831  return lhs.m_value.number_integer < static_cast<number_integer_t>(rhs.m_value.number_unsigned);
22832  }
22833  else if (lhs_type == value_t::number_unsigned && rhs_type == value_t::number_integer)
22834  {
22835  return static_cast<number_integer_t>(lhs.m_value.number_unsigned) < rhs.m_value.number_integer;
22836  }
22837 
22838  // We only reach this line if we cannot compare values. In that case,
22839  // we compare types. Note we have to call the operator explicitly,
22840  // because MSVC has problems otherwise.
22841  return operator<(lhs_type, rhs_type);
22842  }
22843 
22844  /*!
22845  @brief comparison: less than
22846  @copydoc operator<(const_reference, const_reference)
22847  */
22848  template<typename ScalarType, typename std::enable_if<
22849  std::is_scalar<ScalarType>::value, int>::type = 0>
22850  friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
22851  {
22852  return lhs < basic_json(rhs);
22853  }
22854 
22855  /*!
22856  @brief comparison: less than
22857  @copydoc operator<(const_reference, const_reference)
22858  */
22859  template<typename ScalarType, typename std::enable_if<
22860  std::is_scalar<ScalarType>::value, int>::type = 0>
22861  friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
22862  {
22863  return basic_json(lhs) < rhs;
22864  }
22865 
22866  /*!
22867  @brief comparison: less than or equal
22868 
22869  Compares whether one JSON value @a lhs is less than or equal to another
22870  JSON value by calculating `not (rhs < lhs)`.
22871 
22872  @param[in] lhs first JSON value to consider
22873  @param[in] rhs second JSON value to consider
22874  @return whether @a lhs is less than or equal to @a rhs
22875 
22876  @complexity Linear.
22877 
22878  @exceptionsafety No-throw guarantee: this function never throws exceptions.
22879 
22880  @liveexample{The example demonstrates comparing several JSON
22881  types.,operator__greater}
22882 
22883  @since version 1.0.0
22884  */
22885  friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
22886  {
22887  return !(rhs < lhs);
22888  }
22889 
22890  /*!
22891  @brief comparison: less than or equal
22892  @copydoc operator<=(const_reference, const_reference)
22893  */
22894  template<typename ScalarType, typename std::enable_if<
22895  std::is_scalar<ScalarType>::value, int>::type = 0>
22896  friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
22897  {
22898  return lhs <= basic_json(rhs);
22899  }
22900 
22901  /*!
22902  @brief comparison: less than or equal
22903  @copydoc operator<=(const_reference, const_reference)
22904  */
22905  template<typename ScalarType, typename std::enable_if<
22906  std::is_scalar<ScalarType>::value, int>::type = 0>
22907  friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
22908  {
22909  return basic_json(lhs) <= rhs;
22910  }
22911 
22912  /*!
22913  @brief comparison: greater than
22914 
22915  Compares whether one JSON value @a lhs is greater than another
22916  JSON value by calculating `not (lhs <= rhs)`.
22917 
22918  @param[in] lhs first JSON value to consider
22919  @param[in] rhs second JSON value to consider
22920  @return whether @a lhs is greater than to @a rhs
22921 
22922  @complexity Linear.
22923 
22924  @exceptionsafety No-throw guarantee: this function never throws exceptions.
22925 
22926  @liveexample{The example demonstrates comparing several JSON
22927  types.,operator__lessequal}
22928 
22929  @since version 1.0.0
22930  */
22931  friend bool operator>(const_reference lhs, const_reference rhs) noexcept
22932  {
22933  return !(lhs <= rhs);
22934  }
22935 
22936  /*!
22937  @brief comparison: greater than
22938  @copydoc operator>(const_reference, const_reference)
22939  */
22940  template<typename ScalarType, typename std::enable_if<
22941  std::is_scalar<ScalarType>::value, int>::type = 0>
22942  friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
22943  {
22944  return lhs > basic_json(rhs);
22945  }
22946 
22947  /*!
22948  @brief comparison: greater than
22949  @copydoc operator>(const_reference, const_reference)
22950  */
22951  template<typename ScalarType, typename std::enable_if<
22952  std::is_scalar<ScalarType>::value, int>::type = 0>
22953  friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
22954  {
22955  return basic_json(lhs) > rhs;
22956  }
22957 
22958  /*!
22959  @brief comparison: greater than or equal
22960 
22961  Compares whether one JSON value @a lhs is greater than or equal to another
22962  JSON value by calculating `not (lhs < rhs)`.
22963 
22964  @param[in] lhs first JSON value to consider
22965  @param[in] rhs second JSON value to consider
22966  @return whether @a lhs is greater than or equal to @a rhs
22967 
22968  @complexity Linear.
22969 
22970  @exceptionsafety No-throw guarantee: this function never throws exceptions.
22971 
22972  @liveexample{The example demonstrates comparing several JSON
22973  types.,operator__greaterequal}
22974 
22975  @since version 1.0.0
22976  */
22977  friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
22978  {
22979  return !(lhs < rhs);
22980  }
22981 
22982  /*!
22983  @brief comparison: greater than or equal
22984  @copydoc operator>=(const_reference, const_reference)
22985  */
22986  template<typename ScalarType, typename std::enable_if<
22987  std::is_scalar<ScalarType>::value, int>::type = 0>
22988  friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
22989  {
22990  return lhs >= basic_json(rhs);
22991  }
22992 
22993  /*!
22994  @brief comparison: greater than or equal
22995  @copydoc operator>=(const_reference, const_reference)
22996  */
22997  template<typename ScalarType, typename std::enable_if<
22998  std::is_scalar<ScalarType>::value, int>::type = 0>
22999  friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
23000  {
23001  return basic_json(lhs) >= rhs;
23002  }
23003 
23004  /// @}
23005 
23006  ///////////////////
23007  // serialization //
23008  ///////////////////
23009 
23010  /// @name serialization
23011  /// @{
23012 
23013  /*!
23014  @brief serialize to stream
23015 
23016  Serialize the given JSON value @a j to the output stream @a o. The JSON
23017  value will be serialized using the @ref dump member function.
23018 
23019  - The indentation of the output can be controlled with the member variable
23020  `width` of the output stream @a o. For instance, using the manipulator
23021  `std::setw(4)` on @a o sets the indentation level to `4` and the
23022  serialization result is the same as calling `dump(4)`.
23023 
23024  - The indentation character can be controlled with the member variable
23025  `fill` of the output stream @a o. For instance, the manipulator
23026  `std::setfill('\\t')` sets indentation to use a tab character rather than
23027  the default space character.
23028 
23029  @param[in,out] o stream to serialize to
23030  @param[in] j JSON value to serialize
23031 
23032  @return the stream @a o
23033 
23034  @throw type_error.316 if a string stored inside the JSON value is not
23035  UTF-8 encoded
23036 
23037  @complexity Linear.
23038 
23039  @liveexample{The example below shows the serialization with different
23040  parameters to `width` to adjust the indentation level.,operator_serialize}
23041 
23042  @since version 1.0.0; indentation character added in version 3.0.0
23043  */
23044  friend std::ostream& operator<<(std::ostream& o, const basic_json& j)
23045  {
23046  // read width member and use it as indentation parameter if nonzero
23047  const bool pretty_print = o.width() > 0;
23048  const auto indentation = pretty_print ? o.width() : 0;
23049 
23050  // reset width to 0 for subsequent calls to this stream
23051  o.width(0);
23052 
23053  // do the actual serialization
23054  serializer s(detail::output_adapter<char>(o), o.fill());
23055  s.dump(j, pretty_print, false, static_cast<unsigned int>(indentation));
23056  return o;
23057  }
23058 
23059  /*!
23060  @brief serialize to stream
23061  @deprecated This stream operator is deprecated and will be removed in
23062  future 4.0.0 of the library. Please use
23063  @ref operator<<(std::ostream&, const basic_json&)
23064  instead; that is, replace calls like `j >> o;` with `o << j;`.
23065  @since version 1.0.0; deprecated since version 3.0.0
23066  */
23067  JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator<<(std::ostream&, const basic_json&))
23068  friend std::ostream& operator>>(const basic_json& j, std::ostream& o)
23069  {
23070  return o << j;
23071  }
23072 
23073  /// @}
23074 
23075 
23076  /////////////////////
23077  // deserialization //
23078  /////////////////////
23079 
23080  /// @name deserialization
23081  /// @{
23082 
23083  /*!
23084  @brief deserialize from a compatible input
23085 
23086  @tparam InputType A compatible input, for instance
23087  - an std::istream object
23088  - a FILE pointer
23089  - a C-style array of characters
23090  - a pointer to a null-terminated string of single byte characters
23091  - an object obj for which begin(obj) and end(obj) produces a valid pair of
23092  iterators.
23093 
23094  @param[in] i input to read from
23095  @param[in] cb a parser callback function of type @ref parser_callback_t
23096  which is used to control the deserialization by filtering unwanted values
23097  (optional)
23098  @param[in] allow_exceptions whether to throw exceptions in case of a
23099  parse error (optional, true by default)
23100  @param[in] ignore_comments whether comments should be ignored and treated
23101  like whitespace (true) or yield a parse error (true); (optional, false by
23102  default)
23103 
23104  @return deserialized JSON value; in case of a parse error and
23105  @a allow_exceptions set to `false`, the return value will be
23106  value_t::discarded.
23107 
23108  @throw parse_error.101 if a parse error occurs; example: `""unexpected end
23109  of input; expected string literal""`
23110  @throw parse_error.102 if to_unicode fails or surrogate error
23111  @throw parse_error.103 if to_unicode fails
23112 
23113  @complexity Linear in the length of the input. The parser is a predictive
23114  LL(1) parser. The complexity can be higher if the parser callback function
23115  @a cb or reading from the input @a i has a super-linear complexity.
23116 
23117  @note A UTF-8 byte order mark is silently ignored.
23118 
23119  @liveexample{The example below demonstrates the `parse()` function reading
23120  from an array.,parse__array__parser_callback_t}
23121 
23122  @liveexample{The example below demonstrates the `parse()` function with
23123  and without callback function.,parse__string__parser_callback_t}
23124 
23125  @liveexample{The example below demonstrates the `parse()` function with
23126  and without callback function.,parse__istream__parser_callback_t}
23127 
23128  @liveexample{The example below demonstrates the `parse()` function reading
23129  from a contiguous container.,parse__contiguouscontainer__parser_callback_t}
23130 
23131  @since version 2.0.3 (contiguous containers); version 3.9.0 allowed to
23132  ignore comments.
23133  */
23134  template<typename InputType>
23135  JSON_HEDLEY_WARN_UNUSED_RESULT
23136  static basic_json parse(InputType&& i,
23137  const parser_callback_t cb = nullptr,
23138  const bool allow_exceptions = true,
23139  const bool ignore_comments = false)
23140  {
23141  basic_json result;
23142  parser(detail::input_adapter(std::forward<InputType>(i)), cb, allow_exceptions, ignore_comments).parse(true, result);
23143  return result;
23144  }
23145 
23146  /*!
23147  @brief deserialize from a pair of character iterators
23148 
23149  The value_type of the iterator must be a integral type with size of 1, 2 or
23150  4 bytes, which will be interpreted respectively as UTF-8, UTF-16 and UTF-32.
23151 
23152  @param[in] first iterator to start of character range
23153  @param[in] last iterator to end of character range
23154  @param[in] cb a parser callback function of type @ref parser_callback_t
23155  which is used to control the deserialization by filtering unwanted values
23156  (optional)
23157  @param[in] allow_exceptions whether to throw exceptions in case of a
23158  parse error (optional, true by default)
23159  @param[in] ignore_comments whether comments should be ignored and treated
23160  like whitespace (true) or yield a parse error (true); (optional, false by
23161  default)
23162 
23163  @return deserialized JSON value; in case of a parse error and
23164  @a allow_exceptions set to `false`, the return value will be
23165  value_t::discarded.
23166 
23167  @throw parse_error.101 if a parse error occurs; example: `""unexpected end
23168  of input; expected string literal""`
23169  @throw parse_error.102 if to_unicode fails or surrogate error
23170  @throw parse_error.103 if to_unicode fails
23171  */
23172  template<typename IteratorType>
23173  JSON_HEDLEY_WARN_UNUSED_RESULT
23174  static basic_json parse(IteratorType first,
23175  IteratorType last,
23176  const parser_callback_t cb = nullptr,
23177  const bool allow_exceptions = true,
23178  const bool ignore_comments = false)
23179  {
23180  basic_json result;
23181  parser(detail::input_adapter(std::move(first), std::move(last)), cb, allow_exceptions, ignore_comments).parse(true, result);
23182  return result;
23183  }
23184 
23185  JSON_HEDLEY_WARN_UNUSED_RESULT
23186  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, parse(ptr, ptr + len))
23188  const parser_callback_t cb = nullptr,
23189  const bool allow_exceptions = true,
23190  const bool ignore_comments = false)
23191  {
23192  basic_json result;
23193  parser(i.get(), cb, allow_exceptions, ignore_comments).parse(true, result);
23194  return result;
23195  }
23196 
23197  /*!
23198  @brief check if the input is valid JSON
23199 
23200  Unlike the @ref parse(InputType&&, const parser_callback_t,const bool)
23201  function, this function neither throws an exception in case of invalid JSON
23202  input (i.e., a parse error) nor creates diagnostic information.
23203 
23204  @tparam InputType A compatible input, for instance
23205  - an std::istream object
23206  - a FILE pointer
23207  - a C-style array of characters
23208  - a pointer to a null-terminated string of single byte characters
23209  - an object obj for which begin(obj) and end(obj) produces a valid pair of
23210  iterators.
23211 
23212  @param[in] i input to read from
23213  @param[in] ignore_comments whether comments should be ignored and treated
23214  like whitespace (true) or yield a parse error (true); (optional, false by
23215  default)
23216 
23217  @return Whether the input read from @a i is valid JSON.
23218 
23219  @complexity Linear in the length of the input. The parser is a predictive
23220  LL(1) parser.
23221 
23222  @note A UTF-8 byte order mark is silently ignored.
23223 
23224  @liveexample{The example below demonstrates the `accept()` function reading
23225  from a string.,accept__string}
23226  */
23227  template<typename InputType>
23228  static bool accept(InputType&& i,
23229  const bool ignore_comments = false)
23230  {
23231  return parser(detail::input_adapter(std::forward<InputType>(i)), nullptr, false, ignore_comments).accept(true);
23232  }
23233 
23234  template<typename IteratorType>
23235  static bool accept(IteratorType first, IteratorType last,
23236  const bool ignore_comments = false)
23237  {
23238  return parser(detail::input_adapter(std::move(first), std::move(last)), nullptr, false, ignore_comments).accept(true);
23239  }
23240 
23241  JSON_HEDLEY_WARN_UNUSED_RESULT
23242  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, accept(ptr, ptr + len))
23243  static bool accept(detail::span_input_adapter&& i,
23244  const bool ignore_comments = false)
23245  {
23246  return parser(i.get(), nullptr, false, ignore_comments).accept(true);
23247  }
23248 
23249  /*!
23250  @brief generate SAX events
23251 
23252  The SAX event lister must follow the interface of @ref json_sax.
23253 
23254  This function reads from a compatible input. Examples are:
23255  - an std::istream object
23256  - a FILE pointer
23257  - a C-style array of characters
23258  - a pointer to a null-terminated string of single byte characters
23259  - an object obj for which begin(obj) and end(obj) produces a valid pair of
23260  iterators.
23261 
23262  @param[in] i input to read from
23263  @param[in,out] sax SAX event listener
23264  @param[in] format the format to parse (JSON, CBOR, MessagePack, or UBJSON)
23265  @param[in] strict whether the input has to be consumed completely
23266  @param[in] ignore_comments whether comments should be ignored and treated
23267  like whitespace (true) or yield a parse error (true); (optional, false by
23268  default); only applies to the JSON file format.
23269 
23270  @return return value of the last processed SAX event
23271 
23272  @throw parse_error.101 if a parse error occurs; example: `""unexpected end
23273  of input; expected string literal""`
23274  @throw parse_error.102 if to_unicode fails or surrogate error
23275  @throw parse_error.103 if to_unicode fails
23276 
23277  @complexity Linear in the length of the input. The parser is a predictive
23278  LL(1) parser. The complexity can be higher if the SAX consumer @a sax has
23279  a super-linear complexity.
23280 
23281  @note A UTF-8 byte order mark is silently ignored.
23282 
23283  @liveexample{The example below demonstrates the `sax_parse()` function
23284  reading from string and processing the events with a user-defined SAX
23285  event consumer.,sax_parse}
23286 
23287  @since version 3.2.0
23288  */
23289  template <typename InputType, typename SAX>
23290  JSON_HEDLEY_NON_NULL(2)
23291  static bool sax_parse(InputType&& i, SAX* sax,
23293  const bool strict = true,
23294  const bool ignore_comments = false)
23295  {
23296  auto ia = detail::input_adapter(std::forward<InputType>(i));
23297  return format == input_format_t::json
23298  ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23299  : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
23300  }
23301 
23302  template<class IteratorType, class SAX>
23303  JSON_HEDLEY_NON_NULL(3)
23304  static bool sax_parse(IteratorType first, IteratorType last, SAX* sax,
23305  input_format_t format = input_format_t::json,
23306  const bool strict = true,
23307  const bool ignore_comments = false)
23308  {
23309  auto ia = detail::input_adapter(std::move(first), std::move(last));
23310  return format == input_format_t::json
23311  ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23312  : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
23313  }
23314 
23315  template <typename SAX>
23316  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, sax_parse(ptr, ptr + len, ...))
23317  JSON_HEDLEY_NON_NULL(2)
23318  static bool sax_parse(detail::span_input_adapter&& i, SAX* sax,
23319  input_format_t format = input_format_t::json,
23320  const bool strict = true,
23321  const bool ignore_comments = false)
23322  {
23323  auto ia = i.get();
23324  return format == input_format_t::json
23325  ? parser(std::move(ia), nullptr, true, ignore_comments).sax_parse(sax, strict)
23326  : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia)).sax_parse(format, sax, strict);
23327  }
23328 
23329  /*!
23330  @brief deserialize from stream
23331  @deprecated This stream operator is deprecated and will be removed in
23332  version 4.0.0 of the library. Please use
23333  @ref operator>>(std::istream&, basic_json&)
23334  instead; that is, replace calls like `j << i;` with `i >> j;`.
23335  @since version 1.0.0; deprecated since version 3.0.0
23336  */
23337  JSON_HEDLEY_DEPRECATED_FOR(3.0.0, operator>>(std::istream&, basic_json&))
23338  friend std::istream& operator<<(basic_json& j, std::istream& i)
23339  {
23340  return operator>>(i, j);
23341  }
23342 
23343  /*!
23344  @brief deserialize from stream
23345 
23346  Deserializes an input stream to a JSON value.
23347 
23348  @param[in,out] i input stream to read a serialized JSON value from
23349  @param[in,out] j JSON value to write the deserialized input to
23350 
23351  @throw parse_error.101 in case of an unexpected token
23352  @throw parse_error.102 if to_unicode fails or surrogate error
23353  @throw parse_error.103 if to_unicode fails
23354 
23355  @complexity Linear in the length of the input. The parser is a predictive
23356  LL(1) parser.
23357 
23358  @note A UTF-8 byte order mark is silently ignored.
23359 
23360  @liveexample{The example below shows how a JSON value is constructed by
23361  reading a serialization from a stream.,operator_deserialize}
23362 
23363  @sa parse(std::istream&, const parser_callback_t) for a variant with a
23364  parser callback function to filter values while parsing
23365 
23366  @since version 1.0.0
23367  */
23368  friend std::istream& operator>>(std::istream& i, basic_json& j)
23369  {
23370  parser(detail::input_adapter(i)).parse(false, j);
23371  return i;
23372  }
23373 
23374  /// @}
23375 
23376  ///////////////////////////
23377  // convenience functions //
23378  ///////////////////////////
23379 
23380  /*!
23381  @brief return the type as string
23382 
23383  Returns the type name as string to be used in error messages - usually to
23384  indicate that a function was called on a wrong JSON type.
23385 
23386  @return a string representation of a the @a m_type member:
23387  Value type | return value
23388  ----------- | -------------
23389  null | `"null"`
23390  boolean | `"boolean"`
23391  string | `"string"`
23392  number | `"number"` (for all number types)
23393  object | `"object"`
23394  array | `"array"`
23395  binary | `"binary"`
23396  discarded | `"discarded"`
23397 
23398  @exceptionsafety No-throw guarantee: this function never throws exceptions.
23399 
23400  @complexity Constant.
23401 
23402  @liveexample{The following code exemplifies `type_name()` for all JSON
23403  types.,type_name}
23404 
23405  @sa @ref type() -- return the type of the JSON value
23406  @sa @ref operator value_t() -- return the type of the JSON value (implicit)
23407 
23408  @since version 1.0.0, public since 2.1.0, `const char*` and `noexcept`
23409  since 3.0.0
23410  */
23411  JSON_HEDLEY_RETURNS_NON_NULL
23412  const char* type_name() const noexcept
23413  {
23414  {
23415  switch (m_type)
23416  {
23417  case value_t::null:
23418  return "null";
23419  case value_t::object:
23420  return "object";
23421  case value_t::array:
23422  return "array";
23423  case value_t::string:
23424  return "string";
23425  case value_t::boolean:
23426  return "boolean";
23427  case value_t::binary:
23428  return "binary";
23429  case value_t::discarded:
23430  return "discarded";
23431  default:
23432  return "number";
23433  }
23434  }
23435  }
23436 
23437 
23438  private:
23439  //////////////////////
23440  // member variables //
23441  //////////////////////
23442 
23443  /// the type of the current element
23445 
23446  /// the value of the current element
23448 
23449  //////////////////////////////////////////
23450  // binary serialization/deserialization //
23451  //////////////////////////////////////////
23452 
23453  /// @name binary serialization/deserialization support
23454  /// @{
23455 
23456  public:
23457  /*!
23458  @brief create a CBOR serialization of a given JSON value
23459 
23460  Serializes a given JSON value @a j to a byte vector using the CBOR (Concise
23461  Binary Object Representation) serialization format. CBOR is a binary
23462  serialization format which aims to be more compact than JSON itself, yet
23463  more efficient to parse.
23464 
23465  The library uses the following mapping from JSON values types to
23466  CBOR types according to the CBOR specification (RFC 7049):
23467 
23468  JSON value type | value/range | CBOR type | first byte
23469  --------------- | ------------------------------------------ | ---------------------------------- | ---------------
23470  null | `null` | Null | 0xF6
23471  boolean | `true` | True | 0xF5
23472  boolean | `false` | False | 0xF4
23473  number_integer | -9223372036854775808..-2147483649 | Negative integer (8 bytes follow) | 0x3B
23474  number_integer | -2147483648..-32769 | Negative integer (4 bytes follow) | 0x3A
23475  number_integer | -32768..-129 | Negative integer (2 bytes follow) | 0x39
23476  number_integer | -128..-25 | Negative integer (1 byte follow) | 0x38
23477  number_integer | -24..-1 | Negative integer | 0x20..0x37
23478  number_integer | 0..23 | Integer | 0x00..0x17
23479  number_integer | 24..255 | Unsigned integer (1 byte follow) | 0x18
23480  number_integer | 256..65535 | Unsigned integer (2 bytes follow) | 0x19
23481  number_integer | 65536..4294967295 | Unsigned integer (4 bytes follow) | 0x1A
23482  number_integer | 4294967296..18446744073709551615 | Unsigned integer (8 bytes follow) | 0x1B
23483  number_unsigned | 0..23 | Integer | 0x00..0x17
23484  number_unsigned | 24..255 | Unsigned integer (1 byte follow) | 0x18
23485  number_unsigned | 256..65535 | Unsigned integer (2 bytes follow) | 0x19
23486  number_unsigned | 65536..4294967295 | Unsigned integer (4 bytes follow) | 0x1A
23487  number_unsigned | 4294967296..18446744073709551615 | Unsigned integer (8 bytes follow) | 0x1B
23488  number_float | *any value representable by a float* | Single-Precision Float | 0xFA
23489  number_float | *any value NOT representable by a float* | Double-Precision Float | 0xFB
23490  string | *length*: 0..23 | UTF-8 string | 0x60..0x77
23491  string | *length*: 23..255 | UTF-8 string (1 byte follow) | 0x78
23492  string | *length*: 256..65535 | UTF-8 string (2 bytes follow) | 0x79
23493  string | *length*: 65536..4294967295 | UTF-8 string (4 bytes follow) | 0x7A
23494  string | *length*: 4294967296..18446744073709551615 | UTF-8 string (8 bytes follow) | 0x7B
23495  array | *size*: 0..23 | array | 0x80..0x97
23496  array | *size*: 23..255 | array (1 byte follow) | 0x98
23497  array | *size*: 256..65535 | array (2 bytes follow) | 0x99
23498  array | *size*: 65536..4294967295 | array (4 bytes follow) | 0x9A
23499  array | *size*: 4294967296..18446744073709551615 | array (8 bytes follow) | 0x9B
23500  object | *size*: 0..23 | map | 0xA0..0xB7
23501  object | *size*: 23..255 | map (1 byte follow) | 0xB8
23502  object | *size*: 256..65535 | map (2 bytes follow) | 0xB9
23503  object | *size*: 65536..4294967295 | map (4 bytes follow) | 0xBA
23504  object | *size*: 4294967296..18446744073709551615 | map (8 bytes follow) | 0xBB
23505  binary | *size*: 0..23 | byte string | 0x40..0x57
23506  binary | *size*: 23..255 | byte string (1 byte follow) | 0x58
23507  binary | *size*: 256..65535 | byte string (2 bytes follow) | 0x59
23508  binary | *size*: 65536..4294967295 | byte string (4 bytes follow) | 0x5A
23509  binary | *size*: 4294967296..18446744073709551615 | byte string (8 bytes follow) | 0x5B
23510 
23511  @note The mapping is **complete** in the sense that any JSON value type
23512  can be converted to a CBOR value.
23513 
23514  @note If NaN or Infinity are stored inside a JSON number, they are
23515  serialized properly. This behavior differs from the @ref dump()
23516  function which serializes NaN or Infinity to `null`.
23517 
23518  @note The following CBOR types are not used in the conversion:
23519  - UTF-8 strings terminated by "break" (0x7F)
23520  - arrays terminated by "break" (0x9F)
23521  - maps terminated by "break" (0xBF)
23522  - byte strings terminated by "break" (0x5F)
23523  - date/time (0xC0..0xC1)
23524  - bignum (0xC2..0xC3)
23525  - decimal fraction (0xC4)
23526  - bigfloat (0xC5)
23527  - expected conversions (0xD5..0xD7)
23528  - simple values (0xE0..0xF3, 0xF8)
23529  - undefined (0xF7)
23530  - half-precision floats (0xF9)
23531  - break (0xFF)
23532 
23533  @param[in] j JSON value to serialize
23534  @return CBOR serialization as byte vector
23535 
23536  @complexity Linear in the size of the JSON value @a j.
23537 
23538  @liveexample{The example shows the serialization of a JSON value to a byte
23539  vector in CBOR format.,to_cbor}
23540 
23541  @sa http://cbor.io
23542  @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
23543  analogous deserialization
23544  @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
23545  @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
23546  related UBJSON format
23547 
23548  @since version 2.0.9; compact representation of floating-point numbers
23549  since version 3.8.0
23550  */
23551  static std::vector<uint8_t> to_cbor(const basic_json& j)
23552  {
23553  std::vector<uint8_t> result;
23554  to_cbor(j, result);
23555  return result;
23556  }
23557 
23558  static void to_cbor(const basic_json& j, detail::output_adapter<uint8_t> o)
23559  {
23560  binary_writer<uint8_t>(o).write_cbor(j);
23561  }
23562 
23563  static void to_cbor(const basic_json& j, detail::output_adapter<char> o)
23564  {
23565  binary_writer<char>(o).write_cbor(j);
23566  }
23567 
23568  /*!
23569  @brief create a MessagePack serialization of a given JSON value
23570 
23571  Serializes a given JSON value @a j to a byte vector using the MessagePack
23572  serialization format. MessagePack is a binary serialization format which
23573  aims to be more compact than JSON itself, yet more efficient to parse.
23574 
23575  The library uses the following mapping from JSON values types to
23576  MessagePack types according to the MessagePack specification:
23577 
23578  JSON value type | value/range | MessagePack type | first byte
23579  --------------- | --------------------------------- | ---------------- | ----------
23580  null | `null` | nil | 0xC0
23581  boolean | `true` | true | 0xC3
23582  boolean | `false` | false | 0xC2
23583  number_integer | -9223372036854775808..-2147483649 | int64 | 0xD3
23584  number_integer | -2147483648..-32769 | int32 | 0xD2
23585  number_integer | -32768..-129 | int16 | 0xD1
23586  number_integer | -128..-33 | int8 | 0xD0
23587  number_integer | -32..-1 | negative fixint | 0xE0..0xFF
23588  number_integer | 0..127 | positive fixint | 0x00..0x7F
23589  number_integer | 128..255 | uint 8 | 0xCC
23590  number_integer | 256..65535 | uint 16 | 0xCD
23591  number_integer | 65536..4294967295 | uint 32 | 0xCE
23592  number_integer | 4294967296..18446744073709551615 | uint 64 | 0xCF
23593  number_unsigned | 0..127 | positive fixint | 0x00..0x7F
23594  number_unsigned | 128..255 | uint 8 | 0xCC
23595  number_unsigned | 256..65535 | uint 16 | 0xCD
23596  number_unsigned | 65536..4294967295 | uint 32 | 0xCE
23597  number_unsigned | 4294967296..18446744073709551615 | uint 64 | 0xCF
23598  number_float | *any value representable by a float* | float 32 | 0xCA
23599  number_float | *any value NOT representable by a float* | float 64 | 0xCB
23600  string | *length*: 0..31 | fixstr | 0xA0..0xBF
23601  string | *length*: 32..255 | str 8 | 0xD9
23602  string | *length*: 256..65535 | str 16 | 0xDA
23603  string | *length*: 65536..4294967295 | str 32 | 0xDB
23604  array | *size*: 0..15 | fixarray | 0x90..0x9F
23605  array | *size*: 16..65535 | array 16 | 0xDC
23606  array | *size*: 65536..4294967295 | array 32 | 0xDD
23607  object | *size*: 0..15 | fix map | 0x80..0x8F
23608  object | *size*: 16..65535 | map 16 | 0xDE
23609  object | *size*: 65536..4294967295 | map 32 | 0xDF
23610  binary | *size*: 0..255 | bin 8 | 0xC4
23611  binary | *size*: 256..65535 | bin 16 | 0xC5
23612  binary | *size*: 65536..4294967295 | bin 32 | 0xC6
23613 
23614  @note The mapping is **complete** in the sense that any JSON value type
23615  can be converted to a MessagePack value.
23616 
23617  @note The following values can **not** be converted to a MessagePack value:
23618  - strings with more than 4294967295 bytes
23619  - byte strings with more than 4294967295 bytes
23620  - arrays with more than 4294967295 elements
23621  - objects with more than 4294967295 elements
23622 
23623  @note Any MessagePack output created @ref to_msgpack can be successfully
23624  parsed by @ref from_msgpack.
23625 
23626  @note If NaN or Infinity are stored inside a JSON number, they are
23627  serialized properly. This behavior differs from the @ref dump()
23628  function which serializes NaN or Infinity to `null`.
23629 
23630  @param[in] j JSON value to serialize
23631  @return MessagePack serialization as byte vector
23632 
23633  @complexity Linear in the size of the JSON value @a j.
23634 
23635  @liveexample{The example shows the serialization of a JSON value to a byte
23636  vector in MessagePack format.,to_msgpack}
23637 
23638  @sa http://msgpack.org
23639  @sa @ref from_msgpack for the analogous deserialization
23640  @sa @ref to_cbor(const basic_json& for the related CBOR format
23641  @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
23642  related UBJSON format
23643 
23644  @since version 2.0.9
23645  */
23646  static std::vector<uint8_t> to_msgpack(const basic_json& j)
23647  {
23648  std::vector<uint8_t> result;
23649  to_msgpack(j, result);
23650  return result;
23651  }
23652 
23653  static void to_msgpack(const basic_json& j, detail::output_adapter<uint8_t> o)
23654  {
23655  binary_writer<uint8_t>(o).write_msgpack(j);
23656  }
23657 
23658  static void to_msgpack(const basic_json& j, detail::output_adapter<char> o)
23659  {
23660  binary_writer<char>(o).write_msgpack(j);
23661  }
23662 
23663  /*!
23664  @brief create a UBJSON serialization of a given JSON value
23665 
23666  Serializes a given JSON value @a j to a byte vector using the UBJSON
23667  (Universal Binary JSON) serialization format. UBJSON aims to be more compact
23668  than JSON itself, yet more efficient to parse.
23669 
23670  The library uses the following mapping from JSON values types to
23671  UBJSON types according to the UBJSON specification:
23672 
23673  JSON value type | value/range | UBJSON type | marker
23674  --------------- | --------------------------------- | ----------- | ------
23675  null | `null` | null | `Z`
23676  boolean | `true` | true | `T`
23677  boolean | `false` | false | `F`
23678  number_integer | -9223372036854775808..-2147483649 | int64 | `L`
23679  number_integer | -2147483648..-32769 | int32 | `l`
23680  number_integer | -32768..-129 | int16 | `I`
23681  number_integer | -128..127 | int8 | `i`
23682  number_integer | 128..255 | uint8 | `U`
23683  number_integer | 256..32767 | int16 | `I`
23684  number_integer | 32768..2147483647 | int32 | `l`
23685  number_integer | 2147483648..9223372036854775807 | int64 | `L`
23686  number_unsigned | 0..127 | int8 | `i`
23687  number_unsigned | 128..255 | uint8 | `U`
23688  number_unsigned | 256..32767 | int16 | `I`
23689  number_unsigned | 32768..2147483647 | int32 | `l`
23690  number_unsigned | 2147483648..9223372036854775807 | int64 | `L`
23691  number_unsigned | 2147483649..18446744073709551615 | high-precision | `H`
23692  number_float | *any value* | float64 | `D`
23693  string | *with shortest length indicator* | string | `S`
23694  array | *see notes on optimized format* | array | `[`
23695  object | *see notes on optimized format* | map | `{`
23696 
23697  @note The mapping is **complete** in the sense that any JSON value type
23698  can be converted to a UBJSON value.
23699 
23700  @note The following values can **not** be converted to a UBJSON value:
23701  - strings with more than 9223372036854775807 bytes (theoretical)
23702 
23703  @note The following markers are not used in the conversion:
23704  - `Z`: no-op values are not created.
23705  - `C`: single-byte strings are serialized with `S` markers.
23706 
23707  @note Any UBJSON output created @ref to_ubjson can be successfully parsed
23708  by @ref from_ubjson.
23709 
23710  @note If NaN or Infinity are stored inside a JSON number, they are
23711  serialized properly. This behavior differs from the @ref dump()
23712  function which serializes NaN or Infinity to `null`.
23713 
23714  @note The optimized formats for containers are supported: Parameter
23715  @a use_size adds size information to the beginning of a container and
23716  removes the closing marker. Parameter @a use_type further checks
23717  whether all elements of a container have the same type and adds the
23718  type marker to the beginning of the container. The @a use_type
23719  parameter must only be used together with @a use_size = true. Note
23720  that @a use_size = true alone may result in larger representations -
23721  the benefit of this parameter is that the receiving side is
23722  immediately informed on the number of elements of the container.
23723 
23724  @note If the JSON data contains the binary type, the value stored is a list
23725  of integers, as suggested by the UBJSON documentation. In particular,
23726  this means that serialization and the deserialization of a JSON
23727  containing binary values into UBJSON and back will result in a
23728  different JSON object.
23729 
23730  @param[in] j JSON value to serialize
23731  @param[in] use_size whether to add size annotations to container types
23732  @param[in] use_type whether to add type annotations to container types
23733  (must be combined with @a use_size = true)
23734  @return UBJSON serialization as byte vector
23735 
23736  @complexity Linear in the size of the JSON value @a j.
23737 
23738  @liveexample{The example shows the serialization of a JSON value to a byte
23739  vector in UBJSON format.,to_ubjson}
23740 
23741  @sa http://ubjson.org
23742  @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
23743  analogous deserialization
23744  @sa @ref to_cbor(const basic_json& for the related CBOR format
23745  @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
23746 
23747  @since version 3.1.0
23748  */
23749  static std::vector<uint8_t> to_ubjson(const basic_json& j,
23750  const bool use_size = false,
23751  const bool use_type = false)
23752  {
23753  std::vector<uint8_t> result;
23754  to_ubjson(j, result, use_size, use_type);
23755  return result;
23756  }
23757 
23758  static void to_ubjson(const basic_json& j, detail::output_adapter<uint8_t> o,
23759  const bool use_size = false, const bool use_type = false)
23760  {
23761  binary_writer<uint8_t>(o).write_ubjson(j, use_size, use_type);
23762  }
23763 
23764  static void to_ubjson(const basic_json& j, detail::output_adapter<char> o,
23765  const bool use_size = false, const bool use_type = false)
23766  {
23767  binary_writer<char>(o).write_ubjson(j, use_size, use_type);
23768  }
23769 
23770 
23771  /*!
23772  @brief Serializes the given JSON object `j` to BSON and returns a vector
23773  containing the corresponding BSON-representation.
23774 
23775  BSON (Binary JSON) is a binary format in which zero or more ordered key/value pairs are
23776  stored as a single entity (a so-called document).
23777 
23778  The library uses the following mapping from JSON values types to BSON types:
23779 
23780  JSON value type | value/range | BSON type | marker
23781  --------------- | --------------------------------- | ----------- | ------
23782  null | `null` | null | 0x0A
23783  boolean | `true`, `false` | boolean | 0x08
23784  number_integer | -9223372036854775808..-2147483649 | int64 | 0x12
23785  number_integer | -2147483648..2147483647 | int32 | 0x10
23786  number_integer | 2147483648..9223372036854775807 | int64 | 0x12
23787  number_unsigned | 0..2147483647 | int32 | 0x10
23788  number_unsigned | 2147483648..9223372036854775807 | int64 | 0x12
23789  number_unsigned | 9223372036854775808..18446744073709551615| -- | --
23790  number_float | *any value* | double | 0x01
23791  string | *any value* | string | 0x02
23792  array | *any value* | document | 0x04
23793  object | *any value* | document | 0x03
23794  binary | *any value* | binary | 0x05
23795 
23796  @warning The mapping is **incomplete**, since only JSON-objects (and things
23797  contained therein) can be serialized to BSON.
23798  Also, integers larger than 9223372036854775807 cannot be serialized to BSON,
23799  and the keys may not contain U+0000, since they are serialized a
23800  zero-terminated c-strings.
23801 
23802  @throw out_of_range.407 if `j.is_number_unsigned() && j.get<std::uint64_t>() > 9223372036854775807`
23803  @throw out_of_range.409 if a key in `j` contains a NULL (U+0000)
23804  @throw type_error.317 if `!j.is_object()`
23805 
23806  @pre The input `j` is required to be an object: `j.is_object() == true`.
23807 
23808  @note Any BSON output created via @ref to_bson can be successfully parsed
23809  by @ref from_bson.
23810 
23811  @param[in] j JSON value to serialize
23812  @return BSON serialization as byte vector
23813 
23814  @complexity Linear in the size of the JSON value @a j.
23815 
23816  @liveexample{The example shows the serialization of a JSON value to a byte
23817  vector in BSON format.,to_bson}
23818 
23819  @sa http://bsonspec.org/spec.html
23820  @sa @ref from_bson(detail::input_adapter&&, const bool strict) for the
23821  analogous deserialization
23822  @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
23823  related UBJSON format
23824  @sa @ref to_cbor(const basic_json&) for the related CBOR format
23825  @sa @ref to_msgpack(const basic_json&) for the related MessagePack format
23826  */
23827  static std::vector<uint8_t> to_bson(const basic_json& j)
23828  {
23829  std::vector<uint8_t> result;
23830  to_bson(j, result);
23831  return result;
23832  }
23833 
23834  /*!
23835  @brief Serializes the given JSON object `j` to BSON and forwards the
23836  corresponding BSON-representation to the given output_adapter `o`.
23837  @param j The JSON object to convert to BSON.
23838  @param o The output adapter that receives the binary BSON representation.
23839  @pre The input `j` shall be an object: `j.is_object() == true`
23840  @sa @ref to_bson(const basic_json&)
23841  */
23843  {
23845  }
23846 
23847  /*!
23848  @copydoc to_bson(const basic_json&, detail::output_adapter<uint8_t>)
23849  */
23851  {
23853  }
23854 
23855 
23856  /*!
23857  @brief create a JSON value from an input in CBOR format
23858 
23859  Deserializes a given input @a i to a JSON value using the CBOR (Concise
23860  Binary Object Representation) serialization format.
23861 
23862  The library maps CBOR types to JSON value types as follows:
23863 
23864  CBOR type | JSON value type | first byte
23865  ---------------------- | --------------- | ----------
23866  Integer | number_unsigned | 0x00..0x17
23867  Unsigned integer | number_unsigned | 0x18
23868  Unsigned integer | number_unsigned | 0x19
23869  Unsigned integer | number_unsigned | 0x1A
23870  Unsigned integer | number_unsigned | 0x1B
23871  Negative integer | number_integer | 0x20..0x37
23872  Negative integer | number_integer | 0x38
23873  Negative integer | number_integer | 0x39
23874  Negative integer | number_integer | 0x3A
23875  Negative integer | number_integer | 0x3B
23876  Byte string | binary | 0x40..0x57
23877  Byte string | binary | 0x58
23878  Byte string | binary | 0x59
23879  Byte string | binary | 0x5A
23880  Byte string | binary | 0x5B
23881  UTF-8 string | string | 0x60..0x77
23882  UTF-8 string | string | 0x78
23883  UTF-8 string | string | 0x79
23884  UTF-8 string | string | 0x7A
23885  UTF-8 string | string | 0x7B
23886  UTF-8 string | string | 0x7F
23887  array | array | 0x80..0x97
23888  array | array | 0x98
23889  array | array | 0x99
23890  array | array | 0x9A
23891  array | array | 0x9B
23892  array | array | 0x9F
23893  map | object | 0xA0..0xB7
23894  map | object | 0xB8
23895  map | object | 0xB9
23896  map | object | 0xBA
23897  map | object | 0xBB
23898  map | object | 0xBF
23899  False | `false` | 0xF4
23900  True | `true` | 0xF5
23901  Null | `null` | 0xF6
23902  Half-Precision Float | number_float | 0xF9
23903  Single-Precision Float | number_float | 0xFA
23904  Double-Precision Float | number_float | 0xFB
23905 
23906  @warning The mapping is **incomplete** in the sense that not all CBOR
23907  types can be converted to a JSON value. The following CBOR types
23908  are not supported and will yield parse errors (parse_error.112):
23909  - date/time (0xC0..0xC1)
23910  - bignum (0xC2..0xC3)
23911  - decimal fraction (0xC4)
23912  - bigfloat (0xC5)
23913  - expected conversions (0xD5..0xD7)
23914  - simple values (0xE0..0xF3, 0xF8)
23915  - undefined (0xF7)
23916 
23917  @warning CBOR allows map keys of any type, whereas JSON only allows
23918  strings as keys in object values. Therefore, CBOR maps with keys
23919  other than UTF-8 strings are rejected (parse_error.113).
23920 
23921  @note Any CBOR output created @ref to_cbor can be successfully parsed by
23922  @ref from_cbor.
23923 
23924  @param[in] i an input in CBOR format convertible to an input adapter
23925  @param[in] strict whether to expect the input to be consumed until EOF
23926  (true by default)
23927  @param[in] allow_exceptions whether to throw exceptions in case of a
23928  parse error (optional, true by default)
23929  @param[in] tag_handler how to treat CBOR tags (optional, error by default)
23930 
23931  @return deserialized JSON value; in case of a parse error and
23932  @a allow_exceptions set to `false`, the return value will be
23933  value_t::discarded.
23934 
23935  @throw parse_error.110 if the given input ends prematurely or the end of
23936  file was not reached when @a strict was set to true
23937  @throw parse_error.112 if unsupported features from CBOR were
23938  used in the given input @a v or if the input is not valid CBOR
23939  @throw parse_error.113 if a string was expected as map key, but not found
23940 
23941  @complexity Linear in the size of the input @a i.
23942 
23943  @liveexample{The example shows the deserialization of a byte vector in CBOR
23944  format to a JSON value.,from_cbor}
23945 
23946  @sa http://cbor.io
23947  @sa @ref to_cbor(const basic_json&) for the analogous serialization
23948  @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for the
23949  related MessagePack format
23950  @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
23951  related UBJSON format
23952 
23953  @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
23954  consume input adapters, removed start_index parameter, and added
23955  @a strict parameter since 3.0.0; added @a allow_exceptions parameter
23956  since 3.2.0; added @a tag_handler parameter since 3.9.0.
23957  */
23958  template<typename InputType>
23959  JSON_HEDLEY_WARN_UNUSED_RESULT
23960  static basic_json from_cbor(InputType&& i,
23961  const bool strict = true,
23962  const bool allow_exceptions = true,
23963  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23964  {
23965  basic_json result;
23966  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23967  auto ia = detail::input_adapter(std::forward<InputType>(i));
23968  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23969  return res ? result : basic_json(value_t::discarded);
23970  }
23971 
23972  /*!
23973  @copydoc from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t)
23974  */
23975  template<typename IteratorType>
23976  JSON_HEDLEY_WARN_UNUSED_RESULT
23977  static basic_json from_cbor(IteratorType first, IteratorType last,
23978  const bool strict = true,
23979  const bool allow_exceptions = true,
23980  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23981  {
23982  basic_json result;
23983  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
23984  auto ia = detail::input_adapter(std::move(first), std::move(last));
23985  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
23986  return res ? result : basic_json(value_t::discarded);
23987  }
23988 
23989  template<typename T>
23990  JSON_HEDLEY_WARN_UNUSED_RESULT
23991  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
23992  static basic_json from_cbor(const T* ptr, std::size_t len,
23993  const bool strict = true,
23994  const bool allow_exceptions = true,
23995  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
23996  {
23997  return from_cbor(ptr, ptr + len, strict, allow_exceptions, tag_handler);
23998  }
23999 
24000 
24001  JSON_HEDLEY_WARN_UNUSED_RESULT
24002  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_cbor(ptr, ptr + len))
24003  static basic_json from_cbor(detail::span_input_adapter&& i,
24004  const bool strict = true,
24005  const bool allow_exceptions = true,
24006  const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error)
24007  {
24008  basic_json result;
24009  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24010  auto ia = i.get();
24011  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::cbor, &sdp, strict, tag_handler);
24012  return res ? result : basic_json(value_t::discarded);
24013  }
24014 
24015  /*!
24016  @brief create a JSON value from an input in MessagePack format
24017 
24018  Deserializes a given input @a i to a JSON value using the MessagePack
24019  serialization format.
24020 
24021  The library maps MessagePack types to JSON value types as follows:
24022 
24023  MessagePack type | JSON value type | first byte
24024  ---------------- | --------------- | ----------
24025  positive fixint | number_unsigned | 0x00..0x7F
24026  fixmap | object | 0x80..0x8F
24027  fixarray | array | 0x90..0x9F
24028  fixstr | string | 0xA0..0xBF
24029  nil | `null` | 0xC0
24030  false | `false` | 0xC2
24031  true | `true` | 0xC3
24032  float 32 | number_float | 0xCA
24033  float 64 | number_float | 0xCB
24034  uint 8 | number_unsigned | 0xCC
24035  uint 16 | number_unsigned | 0xCD
24036  uint 32 | number_unsigned | 0xCE
24037  uint 64 | number_unsigned | 0xCF
24038  int 8 | number_integer | 0xD0
24039  int 16 | number_integer | 0xD1
24040  int 32 | number_integer | 0xD2
24041  int 64 | number_integer | 0xD3
24042  str 8 | string | 0xD9
24043  str 16 | string | 0xDA
24044  str 32 | string | 0xDB
24045  array 16 | array | 0xDC
24046  array 32 | array | 0xDD
24047  map 16 | object | 0xDE
24048  map 32 | object | 0xDF
24049  bin 8 | binary | 0xC4
24050  bin 16 | binary | 0xC5
24051  bin 32 | binary | 0xC6
24052  ext 8 | binary | 0xC7
24053  ext 16 | binary | 0xC8
24054  ext 32 | binary | 0xC9
24055  fixext 1 | binary | 0xD4
24056  fixext 2 | binary | 0xD5
24057  fixext 4 | binary | 0xD6
24058  fixext 8 | binary | 0xD7
24059  fixext 16 | binary | 0xD8
24060  negative fixint | number_integer | 0xE0-0xFF
24061 
24062  @note Any MessagePack output created @ref to_msgpack can be successfully
24063  parsed by @ref from_msgpack.
24064 
24065  @param[in] i an input in MessagePack format convertible to an input
24066  adapter
24067  @param[in] strict whether to expect the input to be consumed until EOF
24068  (true by default)
24069  @param[in] allow_exceptions whether to throw exceptions in case of a
24070  parse error (optional, true by default)
24071 
24072  @return deserialized JSON value; in case of a parse error and
24073  @a allow_exceptions set to `false`, the return value will be
24074  value_t::discarded.
24075 
24076  @throw parse_error.110 if the given input ends prematurely or the end of
24077  file was not reached when @a strict was set to true
24078  @throw parse_error.112 if unsupported features from MessagePack were
24079  used in the given input @a i or if the input is not valid MessagePack
24080  @throw parse_error.113 if a string was expected as map key, but not found
24081 
24082  @complexity Linear in the size of the input @a i.
24083 
24084  @liveexample{The example shows the deserialization of a byte vector in
24085  MessagePack format to a JSON value.,from_msgpack}
24086 
24087  @sa http://msgpack.org
24088  @sa @ref to_msgpack(const basic_json&) for the analogous serialization
24089  @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
24090  related CBOR format
24091  @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for
24092  the related UBJSON format
24093  @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
24094  the related BSON format
24095 
24096  @since version 2.0.9; parameter @a start_index since 2.1.1; changed to
24097  consume input adapters, removed start_index parameter, and added
24098  @a strict parameter since 3.0.0; added @a allow_exceptions parameter
24099  since 3.2.0
24100  */
24101  template<typename InputType>
24102  JSON_HEDLEY_WARN_UNUSED_RESULT
24103  static basic_json from_msgpack(InputType&& i,
24104  const bool strict = true,
24105  const bool allow_exceptions = true)
24106  {
24107  basic_json result;
24108  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24109  auto ia = detail::input_adapter(std::forward<InputType>(i));
24110  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24111  return res ? result : basic_json(value_t::discarded);
24112  }
24113 
24114  /*!
24115  @copydoc from_msgpack(detail::input_adapter&&, const bool, const bool)
24116  */
24117  template<typename IteratorType>
24118  JSON_HEDLEY_WARN_UNUSED_RESULT
24119  static basic_json from_msgpack(IteratorType first, IteratorType last,
24120  const bool strict = true,
24121  const bool allow_exceptions = true)
24122  {
24123  basic_json result;
24124  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24125  auto ia = detail::input_adapter(std::move(first), std::move(last));
24126  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24127  return res ? result : basic_json(value_t::discarded);
24128  }
24129 
24130 
24131  template<typename T>
24132  JSON_HEDLEY_WARN_UNUSED_RESULT
24133  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
24134  static basic_json from_msgpack(const T* ptr, std::size_t len,
24135  const bool strict = true,
24136  const bool allow_exceptions = true)
24137  {
24138  return from_msgpack(ptr, ptr + len, strict, allow_exceptions);
24139  }
24140 
24141  JSON_HEDLEY_WARN_UNUSED_RESULT
24142  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_msgpack(ptr, ptr + len))
24143  static basic_json from_msgpack(detail::span_input_adapter&& i,
24144  const bool strict = true,
24145  const bool allow_exceptions = true)
24146  {
24147  basic_json result;
24148  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24149  auto ia = i.get();
24150  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::msgpack, &sdp, strict);
24151  return res ? result : basic_json(value_t::discarded);
24152  }
24153 
24154 
24155  /*!
24156  @brief create a JSON value from an input in UBJSON format
24157 
24158  Deserializes a given input @a i to a JSON value using the UBJSON (Universal
24159  Binary JSON) serialization format.
24160 
24161  The library maps UBJSON types to JSON value types as follows:
24162 
24163  UBJSON type | JSON value type | marker
24164  ----------- | --------------------------------------- | ------
24165  no-op | *no value, next value is read* | `N`
24166  null | `null` | `Z`
24167  false | `false` | `F`
24168  true | `true` | `T`
24169  float32 | number_float | `d`
24170  float64 | number_float | `D`
24171  uint8 | number_unsigned | `U`
24172  int8 | number_integer | `i`
24173  int16 | number_integer | `I`
24174  int32 | number_integer | `l`
24175  int64 | number_integer | `L`
24176  high-precision number | number_integer, number_unsigned, or number_float - depends on number string | 'H'
24177  string | string | `S`
24178  char | string | `C`
24179  array | array (optimized values are supported) | `[`
24180  object | object (optimized values are supported) | `{`
24181 
24182  @note The mapping is **complete** in the sense that any UBJSON value can
24183  be converted to a JSON value.
24184 
24185  @param[in] i an input in UBJSON format convertible to an input adapter
24186  @param[in] strict whether to expect the input to be consumed until EOF
24187  (true by default)
24188  @param[in] allow_exceptions whether to throw exceptions in case of a
24189  parse error (optional, true by default)
24190 
24191  @return deserialized JSON value; in case of a parse error and
24192  @a allow_exceptions set to `false`, the return value will be
24193  value_t::discarded.
24194 
24195  @throw parse_error.110 if the given input ends prematurely or the end of
24196  file was not reached when @a strict was set to true
24197  @throw parse_error.112 if a parse error occurs
24198  @throw parse_error.113 if a string could not be parsed successfully
24199 
24200  @complexity Linear in the size of the input @a i.
24201 
24202  @liveexample{The example shows the deserialization of a byte vector in
24203  UBJSON format to a JSON value.,from_ubjson}
24204 
24205  @sa http://ubjson.org
24206  @sa @ref to_ubjson(const basic_json&, const bool, const bool) for the
24207  analogous serialization
24208  @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
24209  related CBOR format
24210  @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
24211  the related MessagePack format
24212  @sa @ref from_bson(detail::input_adapter&&, const bool, const bool) for
24213  the related BSON format
24214 
24215  @since version 3.1.0; added @a allow_exceptions parameter since 3.2.0
24216  */
24217  template<typename InputType>
24218  JSON_HEDLEY_WARN_UNUSED_RESULT
24219  static basic_json from_ubjson(InputType&& i,
24220  const bool strict = true,
24221  const bool allow_exceptions = true)
24222  {
24223  basic_json result;
24224  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24225  auto ia = detail::input_adapter(std::forward<InputType>(i));
24226  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24227  return res ? result : basic_json(value_t::discarded);
24228  }
24229 
24230  /*!
24231  @copydoc from_ubjson(detail::input_adapter&&, const bool, const bool)
24232  */
24233  template<typename IteratorType>
24234  JSON_HEDLEY_WARN_UNUSED_RESULT
24235  static basic_json from_ubjson(IteratorType first, IteratorType last,
24236  const bool strict = true,
24237  const bool allow_exceptions = true)
24238  {
24239  basic_json result;
24240  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24241  auto ia = detail::input_adapter(std::move(first), std::move(last));
24242  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24243  return res ? result : basic_json(value_t::discarded);
24244  }
24245 
24246  template<typename T>
24247  JSON_HEDLEY_WARN_UNUSED_RESULT
24248  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
24249  static basic_json from_ubjson(const T* ptr, std::size_t len,
24250  const bool strict = true,
24251  const bool allow_exceptions = true)
24252  {
24253  return from_ubjson(ptr, ptr + len, strict, allow_exceptions);
24254  }
24255 
24256  JSON_HEDLEY_WARN_UNUSED_RESULT
24257  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_ubjson(ptr, ptr + len))
24258  static basic_json from_ubjson(detail::span_input_adapter&& i,
24259  const bool strict = true,
24260  const bool allow_exceptions = true)
24261  {
24262  basic_json result;
24263  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24264  auto ia = i.get();
24265  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::ubjson, &sdp, strict);
24266  return res ? result : basic_json(value_t::discarded);
24267  }
24268 
24269 
24270  /*!
24271  @brief Create a JSON value from an input in BSON format
24272 
24273  Deserializes a given input @a i to a JSON value using the BSON (Binary JSON)
24274  serialization format.
24275 
24276  The library maps BSON record types to JSON value types as follows:
24277 
24278  BSON type | BSON marker byte | JSON value type
24279  --------------- | ---------------- | ---------------------------
24280  double | 0x01 | number_float
24281  string | 0x02 | string
24282  document | 0x03 | object
24283  array | 0x04 | array
24284  binary | 0x05 | still unsupported
24285  undefined | 0x06 | still unsupported
24286  ObjectId | 0x07 | still unsupported
24287  boolean | 0x08 | boolean
24288  UTC Date-Time | 0x09 | still unsupported
24289  null | 0x0A | null
24290  Regular Expr. | 0x0B | still unsupported
24291  DB Pointer | 0x0C | still unsupported
24292  JavaScript Code | 0x0D | still unsupported
24293  Symbol | 0x0E | still unsupported
24294  JavaScript Code | 0x0F | still unsupported
24295  int32 | 0x10 | number_integer
24296  Timestamp | 0x11 | still unsupported
24297  128-bit decimal float | 0x13 | still unsupported
24298  Max Key | 0x7F | still unsupported
24299  Min Key | 0xFF | still unsupported
24300 
24301  @warning The mapping is **incomplete**. The unsupported mappings
24302  are indicated in the table above.
24303 
24304  @param[in] i an input in BSON format convertible to an input adapter
24305  @param[in] strict whether to expect the input to be consumed until EOF
24306  (true by default)
24307  @param[in] allow_exceptions whether to throw exceptions in case of a
24308  parse error (optional, true by default)
24309 
24310  @return deserialized JSON value; in case of a parse error and
24311  @a allow_exceptions set to `false`, the return value will be
24312  value_t::discarded.
24313 
24314  @throw parse_error.114 if an unsupported BSON record type is encountered
24315 
24316  @complexity Linear in the size of the input @a i.
24317 
24318  @liveexample{The example shows the deserialization of a byte vector in
24319  BSON format to a JSON value.,from_bson}
24320 
24321  @sa http://bsonspec.org/spec.html
24322  @sa @ref to_bson(const basic_json&) for the analogous serialization
24323  @sa @ref from_cbor(detail::input_adapter&&, const bool, const bool, const cbor_tag_handler_t) for the
24324  related CBOR format
24325  @sa @ref from_msgpack(detail::input_adapter&&, const bool, const bool) for
24326  the related MessagePack format
24327  @sa @ref from_ubjson(detail::input_adapter&&, const bool, const bool) for the
24328  related UBJSON format
24329  */
24330  template<typename InputType>
24331  JSON_HEDLEY_WARN_UNUSED_RESULT
24332  static basic_json from_bson(InputType&& i,
24333  const bool strict = true,
24334  const bool allow_exceptions = true)
24335  {
24336  basic_json result;
24337  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24338  auto ia = detail::input_adapter(std::forward<InputType>(i));
24339  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
24340  return res ? result : basic_json(value_t::discarded);
24341  }
24342 
24343  /*!
24344  @copydoc from_bson(detail::input_adapter&&, const bool, const bool)
24345  */
24346  template<typename IteratorType>
24347  JSON_HEDLEY_WARN_UNUSED_RESULT
24348  static basic_json from_bson(IteratorType first, IteratorType last,
24349  const bool strict = true,
24350  const bool allow_exceptions = true)
24351  {
24352  basic_json result;
24353  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24354  auto ia = detail::input_adapter(std::move(first), std::move(last));
24355  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
24356  return res ? result : basic_json(value_t::discarded);
24357  }
24358 
24359  template<typename T>
24360  JSON_HEDLEY_WARN_UNUSED_RESULT
24361  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
24362  static basic_json from_bson(const T* ptr, std::size_t len,
24363  const bool strict = true,
24364  const bool allow_exceptions = true)
24365  {
24366  return from_bson(ptr, ptr + len, strict, allow_exceptions);
24367  }
24368 
24369  JSON_HEDLEY_WARN_UNUSED_RESULT
24370  JSON_HEDLEY_DEPRECATED_FOR(3.8.0, from_bson(ptr, ptr + len))
24371  static basic_json from_bson(detail::span_input_adapter&& i,
24372  const bool strict = true,
24373  const bool allow_exceptions = true)
24374  {
24375  basic_json result;
24376  detail::json_sax_dom_parser<basic_json> sdp(result, allow_exceptions);
24377  auto ia = i.get();
24378  const bool res = binary_reader<decltype(ia)>(std::move(ia)).sax_parse(input_format_t::bson, &sdp, strict);
24379  return res ? result : basic_json(value_t::discarded);
24380  }
24381  /// @}
24382 
24383  //////////////////////////
24384  // JSON Pointer support //
24385  //////////////////////////
24386 
24387  /// @name JSON Pointer functions
24388  /// @{
24389 
24390  /*!
24391  @brief access specified element via JSON Pointer
24392 
24393  Uses a JSON pointer to retrieve a reference to the respective JSON value.
24394  No bound checking is performed. Similar to @ref operator[](const typename
24395  object_t::key_type&), `null` values are created in arrays and objects if
24396  necessary.
24397 
24398  In particular:
24399  - If the JSON pointer points to an object key that does not exist, it
24400  is created an filled with a `null` value before a reference to it
24401  is returned.
24402  - If the JSON pointer points to an array index that does not exist, it
24403  is created an filled with a `null` value before a reference to it
24404  is returned. All indices between the current maximum and the given
24405  index are also filled with `null`.
24406  - The special value `-` is treated as a synonym for the index past the
24407  end.
24408 
24409  @param[in] ptr a JSON pointer
24410 
24411  @return reference to the element pointed to by @a ptr
24412 
24413  @complexity Constant.
24414 
24415  @throw parse_error.106 if an array index begins with '0'
24416  @throw parse_error.109 if an array index was not a number
24417  @throw out_of_range.404 if the JSON pointer can not be resolved
24418 
24419  @liveexample{The behavior is shown in the example.,operatorjson_pointer}
24420 
24421  @since version 2.0.0
24422  */
24424  {
24425  return ptr.get_unchecked(this);
24426  }
24427 
24428  /*!
24429  @brief access specified element via JSON Pointer
24430 
24431  Uses a JSON pointer to retrieve a reference to the respective JSON value.
24432  No bound checking is performed. The function does not change the JSON
24433  value; no `null` values are created. In particular, the special value
24434  `-` yields an exception.
24435 
24436  @param[in] ptr JSON pointer to the desired element
24437 
24438  @return const reference to the element pointed to by @a ptr
24439 
24440  @complexity Constant.
24441 
24442  @throw parse_error.106 if an array index begins with '0'
24443  @throw parse_error.109 if an array index was not a number
24444  @throw out_of_range.402 if the array index '-' is used
24445  @throw out_of_range.404 if the JSON pointer can not be resolved
24446 
24447  @liveexample{The behavior is shown in the example.,operatorjson_pointer_const}
24448 
24449  @since version 2.0.0
24450  */
24452  {
24453  return ptr.get_unchecked(this);
24454  }
24455 
24456  /*!
24457  @brief access specified element via JSON Pointer
24458 
24459  Returns a reference to the element at with specified JSON pointer @a ptr,
24460  with bounds checking.
24461 
24462  @param[in] ptr JSON pointer to the desired element
24463 
24464  @return reference to the element pointed to by @a ptr
24465 
24466  @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
24467  begins with '0'. See example below.
24468 
24469  @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
24470  is not a number. See example below.
24471 
24472  @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
24473  is out of range. See example below.
24474 
24475  @throw out_of_range.402 if the array index '-' is used in the passed JSON
24476  pointer @a ptr. As `at` provides checked access (and no elements are
24477  implicitly inserted), the index '-' is always invalid. See example below.
24478 
24479  @throw out_of_range.403 if the JSON pointer describes a key of an object
24480  which cannot be found. See example below.
24481 
24482  @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
24483  See example below.
24484 
24485  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
24486  changes in the JSON value.
24487 
24488  @complexity Constant.
24489 
24490  @since version 2.0.0
24491 
24492  @liveexample{The behavior is shown in the example.,at_json_pointer}
24493  */
24495  {
24496  return ptr.get_checked(this);
24497  }
24498 
24499  /*!
24500  @brief access specified element via JSON Pointer
24501 
24502  Returns a const reference to the element at with specified JSON pointer @a
24503  ptr, with bounds checking.
24504 
24505  @param[in] ptr JSON pointer to the desired element
24506 
24507  @return reference to the element pointed to by @a ptr
24508 
24509  @throw parse_error.106 if an array index in the passed JSON pointer @a ptr
24510  begins with '0'. See example below.
24511 
24512  @throw parse_error.109 if an array index in the passed JSON pointer @a ptr
24513  is not a number. See example below.
24514 
24515  @throw out_of_range.401 if an array index in the passed JSON pointer @a ptr
24516  is out of range. See example below.
24517 
24518  @throw out_of_range.402 if the array index '-' is used in the passed JSON
24519  pointer @a ptr. As `at` provides checked access (and no elements are
24520  implicitly inserted), the index '-' is always invalid. See example below.
24521 
24522  @throw out_of_range.403 if the JSON pointer describes a key of an object
24523  which cannot be found. See example below.
24524 
24525  @throw out_of_range.404 if the JSON pointer @a ptr can not be resolved.
24526  See example below.
24527 
24528  @exceptionsafety Strong guarantee: if an exception is thrown, there are no
24529  changes in the JSON value.
24530 
24531  @complexity Constant.
24532 
24533  @since version 2.0.0
24534 
24535  @liveexample{The behavior is shown in the example.,at_json_pointer_const}
24536  */
24537  const_reference at(const json_pointer& ptr) const
24538  {
24539  return ptr.get_checked(this);
24540  }
24541 
24542  /*!
24543  @brief return flattened JSON value
24544 
24545  The function creates a JSON object whose keys are JSON pointers (see [RFC
24546  6901](https://tools.ietf.org/html/rfc6901)) and whose values are all
24547  primitive. The original JSON value can be restored using the @ref
24548  unflatten() function.
24549 
24550  @return an object that maps JSON pointers to primitive values
24551 
24552  @note Empty objects and arrays are flattened to `null` and will not be
24553  reconstructed correctly by the @ref unflatten() function.
24554 
24555  @complexity Linear in the size the JSON value.
24556 
24557  @liveexample{The following code shows how a JSON object is flattened to an
24558  object whose keys consist of JSON pointers.,flatten}
24559 
24560  @sa @ref unflatten() for the reverse function
24561 
24562  @since version 2.0.0
24563  */
24565  {
24566  basic_json result(value_t::object);
24567  json_pointer::flatten("", *this, result);
24568  return result;
24569  }
24570 
24571  /*!
24572  @brief unflatten a previously flattened JSON value
24573 
24574  The function restores the arbitrary nesting of a JSON value that has been
24575  flattened before using the @ref flatten() function. The JSON value must
24576  meet certain constraints:
24577  1. The value must be an object.
24578  2. The keys must be JSON pointers (see
24579  [RFC 6901](https://tools.ietf.org/html/rfc6901))
24580  3. The mapped values must be primitive JSON types.
24581 
24582  @return the original JSON from a flattened version
24583 
24584  @note Empty objects and arrays are flattened by @ref flatten() to `null`
24585  values and can not unflattened to their original type. Apart from
24586  this example, for a JSON value `j`, the following is always true:
24587  `j == j.flatten().unflatten()`.
24588 
24589  @complexity Linear in the size the JSON value.
24590 
24591  @throw type_error.314 if value is not an object
24592  @throw type_error.315 if object values are not primitive
24593 
24594  @liveexample{The following code shows how a flattened JSON object is
24595  unflattened into the original nested JSON object.,unflatten}
24596 
24597  @sa @ref flatten() for the reverse function
24598 
24599  @since version 2.0.0
24600  */
24602  {
24603  return json_pointer::unflatten(*this);
24604  }
24605 
24606  /// @}
24607 
24608  //////////////////////////
24609  // JSON Patch functions //
24610  //////////////////////////
24611 
24612  /// @name JSON Patch functions
24613  /// @{
24614 
24615  /*!
24616  @brief applies a JSON patch
24617 
24618  [JSON Patch](http://jsonpatch.com) defines a JSON document structure for
24619  expressing a sequence of operations to apply to a JSON) document. With
24620  this function, a JSON Patch is applied to the current JSON value by
24621  executing all operations from the patch.
24622 
24623  @param[in] json_patch JSON patch document
24624  @return patched document
24625 
24626  @note The application of a patch is atomic: Either all operations succeed
24627  and the patched document is returned or an exception is thrown. In
24628  any case, the original value is not changed: the patch is applied
24629  to a copy of the value.
24630 
24631  @throw parse_error.104 if the JSON patch does not consist of an array of
24632  objects
24633 
24634  @throw parse_error.105 if the JSON patch is malformed (e.g., mandatory
24635  attributes are missing); example: `"operation add must have member path"`
24636 
24637  @throw out_of_range.401 if an array index is out of range.
24638 
24639  @throw out_of_range.403 if a JSON pointer inside the patch could not be
24640  resolved successfully in the current JSON value; example: `"key baz not
24641  found"`
24642 
24643  @throw out_of_range.405 if JSON pointer has no parent ("add", "remove",
24644  "move")
24645 
24646  @throw other_error.501 if "test" operation was unsuccessful
24647 
24648  @complexity Linear in the size of the JSON value and the length of the
24649  JSON patch. As usually only a fraction of the JSON value is affected by
24650  the patch, the complexity can usually be neglected.
24651 
24652  @liveexample{The following code shows how a JSON patch is applied to a
24653  value.,patch}
24654 
24655  @sa @ref diff -- create a JSON patch by comparing two JSON values
24656 
24657  @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
24658  @sa [RFC 6901 (JSON Pointer)](https://tools.ietf.org/html/rfc6901)
24659 
24660  @since version 2.0.0
24661  */
24662  basic_json patch(const basic_json& json_patch) const
24663  {
24664  // make a working copy to apply the patch to
24665  basic_json result = *this;
24666 
24667  // the valid JSON Patch operations
24668  enum class patch_operations {add, remove, replace, move, copy, test, invalid};
24669 
24670  const auto get_op = [](const std::string & op)
24671  {
24672  if (op == "add")
24673  {
24674  return patch_operations::add;
24675  }
24676  if (op == "remove")
24677  {
24678  return patch_operations::remove;
24679  }
24680  if (op == "replace")
24681  {
24682  return patch_operations::replace;
24683  }
24684  if (op == "move")
24685  {
24686  return patch_operations::move;
24687  }
24688  if (op == "copy")
24689  {
24690  return patch_operations::copy;
24691  }
24692  if (op == "test")
24693  {
24694  return patch_operations::test;
24695  }
24696 
24697  return patch_operations::invalid;
24698  };
24699 
24700  // wrapper for "add" operation; add value at ptr
24701  const auto operation_add = [&result](json_pointer & ptr, basic_json val)
24702  {
24703  // adding to the root of the target document means replacing it
24704  if (ptr.empty())
24705  {
24706  result = val;
24707  return;
24708  }
24709 
24710  // make sure the top element of the pointer exists
24711  json_pointer top_pointer = ptr.top();
24712  if (top_pointer != ptr)
24713  {
24714  result.at(top_pointer);
24715  }
24716 
24717  // get reference to parent of JSON pointer ptr
24718  const auto last_path = ptr.back();
24719  ptr.pop_back();
24720  basic_json& parent = result[ptr];
24721 
24722  switch (parent.m_type)
24723  {
24724  case value_t::null:
24725  case value_t::object:
24726  {
24727  // use operator[] to add value
24728  parent[last_path] = val;
24729  break;
24730  }
24731 
24732  case value_t::array:
24733  {
24734  if (last_path == "-")
24735  {
24736  // special case: append to back
24737  parent.push_back(val);
24738  }
24739  else
24740  {
24741  const auto idx = json_pointer::array_index(last_path);
24742  if (JSON_HEDLEY_UNLIKELY(idx > parent.size()))
24743  {
24744  // avoid undefined behavior
24745  JSON_THROW(out_of_range::create(401, "array index " + std::to_string(idx) + " is out of range"));
24746  }
24747 
24748  // default case: insert add offset
24749  parent.insert(parent.begin() + static_cast<difference_type>(idx), val);
24750  }
24751  break;
24752  }
24753 
24754  // if there exists a parent it cannot be primitive
24755  default: // LCOV_EXCL_LINE
24756  JSON_ASSERT(false); // LCOV_EXCL_LINE
24757  }
24758  };
24759 
24760  // wrapper for "remove" operation; remove value at ptr
24761  const auto operation_remove = [&result](json_pointer & ptr)
24762  {
24763  // get reference to parent of JSON pointer ptr
24764  const auto last_path = ptr.back();
24765  ptr.pop_back();
24766  basic_json& parent = result.at(ptr);
24767 
24768  // remove child
24769  if (parent.is_object())
24770  {
24771  // perform range check
24772  auto it = parent.find(last_path);
24773  if (JSON_HEDLEY_LIKELY(it != parent.end()))
24774  {
24775  parent.erase(it);
24776  }
24777  else
24778  {
24779  JSON_THROW(out_of_range::create(403, "key '" + last_path + "' not found"));
24780  }
24781  }
24782  else if (parent.is_array())
24783  {
24784  // note erase performs range check
24785  parent.erase(json_pointer::array_index(last_path));
24786  }
24787  };
24788 
24789  // type check: top level value must be an array
24790  if (JSON_HEDLEY_UNLIKELY(!json_patch.is_array()))
24791  {
24792  JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
24793  }
24794 
24795  // iterate and apply the operations
24796  for (const auto& val : json_patch)
24797  {
24798  // wrapper to get a value for an operation
24799  const auto get_value = [&val](const std::string & op,
24800  const std::string & member,
24801  bool string_type) -> basic_json &
24802  {
24803  // find value
24804  auto it = val.m_value.object->find(member);
24805 
24806  // context-sensitive error message
24807  const auto error_msg = (op == "op") ? "operation" : "operation '" + op + "'";
24808 
24809  // check if desired value is present
24810  if (JSON_HEDLEY_UNLIKELY(it == val.m_value.object->end()))
24811  {
24812  JSON_THROW(parse_error::create(105, 0, error_msg + " must have member '" + member + "'"));
24813  }
24814 
24815  // check if result is of type string
24816  if (JSON_HEDLEY_UNLIKELY(string_type && !it->second.is_string()))
24817  {
24818  JSON_THROW(parse_error::create(105, 0, error_msg + " must have string member '" + member + "'"));
24819  }
24820 
24821  // no error: return value
24822  return it->second;
24823  };
24824 
24825  // type check: every element of the array must be an object
24826  if (JSON_HEDLEY_UNLIKELY(!val.is_object()))
24827  {
24828  JSON_THROW(parse_error::create(104, 0, "JSON patch must be an array of objects"));
24829  }
24830 
24831  // collect mandatory members
24832  const auto op = get_value("op", "op", true).template get<std::string>();
24833  const auto path = get_value(op, "path", true).template get<std::string>();
24834  json_pointer ptr(path);
24835 
24836  switch (get_op(op))
24837  {
24838  case patch_operations::add:
24839  {
24840  operation_add(ptr, get_value("add", "value", false));
24841  break;
24842  }
24843 
24844  case patch_operations::remove:
24845  {
24846  operation_remove(ptr);
24847  break;
24848  }
24849 
24850  case patch_operations::replace:
24851  {
24852  // the "path" location must exist - use at()
24853  result.at(ptr) = get_value("replace", "value", false);
24854  break;
24855  }
24856 
24857  case patch_operations::move:
24858  {
24859  const auto from_path = get_value("move", "from", true).template get<std::string>();
24860  json_pointer from_ptr(from_path);
24861 
24862  // the "from" location must exist - use at()
24863  basic_json v = result.at(from_ptr);
24864 
24865  // The move operation is functionally identical to a
24866  // "remove" operation on the "from" location, followed
24867  // immediately by an "add" operation at the target
24868  // location with the value that was just removed.
24869  operation_remove(from_ptr);
24870  operation_add(ptr, v);
24871  break;
24872  }
24873 
24874  case patch_operations::copy:
24875  {
24876  const auto from_path = get_value("copy", "from", true).template get<std::string>();
24877  const json_pointer from_ptr(from_path);
24878 
24879  // the "from" location must exist - use at()
24880  basic_json v = result.at(from_ptr);
24881 
24882  // The copy is functionally identical to an "add"
24883  // operation at the target location using the value
24884  // specified in the "from" member.
24885  operation_add(ptr, v);
24886  break;
24887  }
24888 
24889  case patch_operations::test:
24890  {
24891  bool success = false;
24892  JSON_TRY
24893  {
24894  // check if "value" matches the one at "path"
24895  // the "path" location must exist - use at()
24896  success = (result.at(ptr) == get_value("test", "value", false));
24897  }
24898  JSON_INTERNAL_CATCH (out_of_range&)
24899  {
24900  // ignore out of range errors: success remains false
24901  }
24902 
24903  // throw an exception if test fails
24904  if (JSON_HEDLEY_UNLIKELY(!success))
24905  {
24906  JSON_THROW(other_error::create(501, "unsuccessful: " + val.dump()));
24907  }
24908 
24909  break;
24910  }
24911 
24912  default:
24913  {
24914  // op must be "add", "remove", "replace", "move", "copy", or
24915  // "test"
24916  JSON_THROW(parse_error::create(105, 0, "operation value '" + op + "' is invalid"));
24917  }
24918  }
24919  }
24920 
24921  return result;
24922  }
24923 
24924  /*!
24925  @brief creates a diff as a JSON patch
24926 
24927  Creates a [JSON Patch](http://jsonpatch.com) so that value @a source can
24928  be changed into the value @a target by calling @ref patch function.
24929 
24930  @invariant For two JSON values @a source and @a target, the following code
24931  yields always `true`:
24932  @code {.cpp}
24933  source.patch(diff(source, target)) == target;
24934  @endcode
24935 
24936  @note Currently, only `remove`, `add`, and `replace` operations are
24937  generated.
24938 
24939  @param[in] source JSON value to compare from
24940  @param[in] target JSON value to compare against
24941  @param[in] path helper value to create JSON pointers
24942 
24943  @return a JSON patch to convert the @a source to @a target
24944 
24945  @complexity Linear in the lengths of @a source and @a target.
24946 
24947  @liveexample{The following code shows how a JSON patch is created as a
24948  diff for two JSON values.,diff}
24949 
24950  @sa @ref patch -- apply a JSON patch
24951  @sa @ref merge_patch -- apply a JSON Merge Patch
24952 
24953  @sa [RFC 6902 (JSON Patch)](https://tools.ietf.org/html/rfc6902)
24954 
24955  @since version 2.0.0
24956  */
24957  JSON_HEDLEY_WARN_UNUSED_RESULT
24958  static basic_json diff(const basic_json& source, const basic_json& target,
24959  const std::string& path = "")
24960  {
24961  // the patch
24962  basic_json result(value_t::array);
24963 
24964  // if the values are the same, return empty patch
24965  if (source == target)
24966  {
24967  return result;
24968  }
24969 
24970  if (source.type() != target.type())
24971  {
24972  // different types: replace value
24973  result.push_back(
24974  {
24975  {"op", "replace"}, {"path", path}, {"value", target}
24976  });
24977  return result;
24978  }
24979 
24980  switch (source.type())
24981  {
24982  case value_t::array:
24983  {
24984  // first pass: traverse common elements
24985  std::size_t i = 0;
24986  while (i < source.size() && i < target.size())
24987  {
24988  // recursive call to compare array values at index i
24989  auto temp_diff = diff(source[i], target[i], path + "/" + std::to_string(i));
24990  result.insert(result.end(), temp_diff.begin(), temp_diff.end());
24991  ++i;
24992  }
24993 
24994  // i now reached the end of at least one array
24995  // in a second pass, traverse the remaining elements
24996 
24997  // remove my remaining elements
24998  const auto end_index = static_cast<difference_type>(result.size());
24999  while (i < source.size())
25000  {
25001  // add operations in reverse order to avoid invalid
25002  // indices
25003  result.insert(result.begin() + end_index, object(
25004  {
25005  {"op", "remove"},
25006  {"path", path + "/" + std::to_string(i)}
25007  }));
25008  ++i;
25009  }
25010 
25011  // add other remaining elements
25012  while (i < target.size())
25013  {
25014  result.push_back(
25015  {
25016  {"op", "add"},
25017  {"path", path + "/-"},
25018  {"value", target[i]}
25019  });
25020  ++i;
25021  }
25022 
25023  break;
25024  }
25025 
25026  case value_t::object:
25027  {
25028  // first pass: traverse this object's elements
25029  for (auto it = source.cbegin(); it != source.cend(); ++it)
25030  {
25031  // escape the key name to be used in a JSON patch
25032  const auto key = json_pointer::escape(it.key());
25033 
25034  if (target.find(it.key()) != target.end())
25035  {
25036  // recursive call to compare object values at key it
25037  auto temp_diff = diff(it.value(), target[it.key()], path + "/" + key);
25038  result.insert(result.end(), temp_diff.begin(), temp_diff.end());
25039  }
25040  else
25041  {
25042  // found a key that is not in o -> remove it
25043  result.push_back(object(
25044  {
25045  {"op", "remove"}, {"path", path + "/" + key}
25046  }));
25047  }
25048  }
25049 
25050  // second pass: traverse other object's elements
25051  for (auto it = target.cbegin(); it != target.cend(); ++it)
25052  {
25053  if (source.find(it.key()) == source.end())
25054  {
25055  // found a key that is not in this -> add it
25056  const auto key = json_pointer::escape(it.key());
25057  result.push_back(
25058  {
25059  {"op", "add"}, {"path", path + "/" + key},
25060  {"value", it.value()}
25061  });
25062  }
25063  }
25064 
25065  break;
25066  }
25067 
25068  default:
25069  {
25070  // both primitive type: replace value
25071  result.push_back(
25072  {
25073  {"op", "replace"}, {"path", path}, {"value", target}
25074  });
25075  break;
25076  }
25077  }
25078 
25079  return result;
25080  }
25081 
25082  /// @}
25083 
25084  ////////////////////////////////
25085  // JSON Merge Patch functions //
25086  ////////////////////////////////
25087 
25088  /// @name JSON Merge Patch functions
25089  /// @{
25090 
25091  /*!
25092  @brief applies a JSON Merge Patch
25093 
25094  The merge patch format is primarily intended for use with the HTTP PATCH
25095  method as a means of describing a set of modifications to a target
25096  resource's content. This function applies a merge patch to the current
25097  JSON value.
25098 
25099  The function implements the following algorithm from Section 2 of
25100  [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396):
25101 
25102  ```
25103  define MergePatch(Target, Patch):
25104  if Patch is an Object:
25105  if Target is not an Object:
25106  Target = {} // Ignore the contents and set it to an empty Object
25107  for each Name/Value pair in Patch:
25108  if Value is null:
25109  if Name exists in Target:
25110  remove the Name/Value pair from Target
25111  else:
25112  Target[Name] = MergePatch(Target[Name], Value)
25113  return Target
25114  else:
25115  return Patch
25116  ```
25117 
25118  Thereby, `Target` is the current object; that is, the patch is applied to
25119  the current value.
25120 
25121  @param[in] apply_patch the patch to apply
25122 
25123  @complexity Linear in the lengths of @a patch.
25124 
25125  @liveexample{The following code shows how a JSON Merge Patch is applied to
25126  a JSON document.,merge_patch}
25127 
25128  @sa @ref patch -- apply a JSON patch
25129  @sa [RFC 7396 (JSON Merge Patch)](https://tools.ietf.org/html/rfc7396)
25130 
25131  @since version 3.0.0
25132  */
25133  void merge_patch(const basic_json& apply_patch)
25134  {
25135  if (apply_patch.is_object())
25136  {
25137  if (!is_object())
25138  {
25139  *this = object();
25140  }
25141  for (auto it = apply_patch.begin(); it != apply_patch.end(); ++it)
25142  {
25143  if (it.value().is_null())
25144  {
25145  erase(it.key());
25146  }
25147  else
25148  {
25149  operator[](it.key()).merge_patch(it.value());
25150  }
25151  }
25152  }
25153  else
25154  {
25155  *this = apply_patch;
25156  }
25157  }
25158 
25159  /// @}
25160 };
25161 
25162 /*!
25163 @brief user-defined to_string function for JSON values
25164 
25165 This function implements a user-defined to_string for JSON objects.
25166 
25167 @param[in] j a JSON object
25168 @return a std::string object
25169 */
25170 
25171 NLOHMANN_BASIC_JSON_TPL_DECLARATION
25172 std::string to_string(const NLOHMANN_BASIC_JSON_TPL& j)
25173 {
25174  return j.dump();
25175 }
25176 } // namespace nlohmann
25177 
25178 ///////////////////////
25179 // nonmember support //
25180 ///////////////////////
25181 
25182 // specialization of std::swap, and std::hash
25183 namespace std
25184 {
25185 
25186 /// hash value for JSON objects
25187 template<>
25189 {
25190  /*!
25191  @brief return a hash value for a JSON object
25192 
25193  @since version 1.0.0
25194  */
25195  std::size_t operator()(const nlohmann::json& j) const
25196  {
25197  return nlohmann::detail::hash(j);
25198  }
25199 };
25200 
25201 /// specialization for std::less<value_t>
25202 /// @note: do not remove the space after '<',
25203 /// see https://github.com/nlohmann/json/pull/679
25204 template<>
25206 {
25207  /*!
25208  @brief compare two value_t enum values
25209  @since version 3.0.0
25210  */
25212  nlohmann::detail::value_t rhs) const noexcept
25213  {
25214  return nlohmann::detail::operator<(lhs, rhs);
25215  }
25216 };
25217 
25218 // C++20 prohibit function specialization in the std namespace.
25219 #ifndef JSON_HAS_CPP_20
25220 
25221 /*!
25222 @brief exchanges the values of two JSON objects
25223 
25224 @since version 1.0.0
25225 */
25226 template<>
25227 inline void swap<nlohmann::json>(nlohmann::json& j1, nlohmann::json& j2) noexcept(
25228  is_nothrow_move_constructible<nlohmann::json>::value&&
25229  is_nothrow_move_assignable<nlohmann::json>::value
25230  )
25231 {
25232  j1.swap(j2);
25233 }
25234 
25235 #endif
25236 
25237 } // namespace std
25238 
25239 /*!
25240 @brief user-defined string literal for JSON values
25241 
25242 This operator implements a user-defined string literal for JSON objects. It
25243 can be used by adding `"_json"` to a string literal and returns a JSON object
25244 if no parse error occurred.
25245 
25246 @param[in] s a string representation of a JSON object
25247 @param[in] n the length of string @a s
25248 @return a JSON object
25249 
25250 @since version 1.0.0
25251 */
25252 JSON_HEDLEY_NON_NULL(1)
25253 inline nlohmann::json operator "" _json(const char* s, std::size_t n)
25254 {
25255  return nlohmann::json::parse(s, s + n);
25256 }
25257 
25258 /*!
25259 @brief user-defined string literal for JSON pointer
25260 
25261 This operator implements a user-defined string literal for JSON Pointers. It
25262 can be used by adding `"_json_pointer"` to a string literal and returns a JSON pointer
25263 object if no parse error occurred.
25264 
25265 @param[in] s a string representation of a JSON Pointer
25266 @param[in] n the length of string @a s
25267 @return a JSON pointer object
25268 
25269 @since version 2.0.0
25270 */
25271 JSON_HEDLEY_NON_NULL(1)
25272 inline nlohmann::json::json_pointer operator "" _json_pointer(const char* s, std::size_t n)
25273 {
25274  return nlohmann::json::json_pointer(std::string(s, n));
25275 }
25276 
25277 // #include <nlohmann/detail/macro_unscope.hpp>
25278 
25279 
25280 // restore GCC/clang diagnostic settings
25281 #if defined(__clang__) || defined(__GNUC__) || defined(__GNUG__)
25282  #pragma GCC diagnostic pop
25283 #endif
25284 #if defined(__clang__)
25285  #pragma GCC diagnostic pop
25286 #endif
25287 
25288 // clean up
25289 #undef JSON_ASSERT
25290 #undef JSON_INTERNAL_CATCH
25291 #undef JSON_CATCH
25292 #undef JSON_THROW
25293 #undef JSON_TRY
25294 #undef JSON_HAS_CPP_14
25295 #undef JSON_HAS_CPP_17
25296 #undef NLOHMANN_BASIC_JSON_TPL_DECLARATION
25297 #undef NLOHMANN_BASIC_JSON_TPL
25298 #undef JSON_EXPLICIT
25299 
25300 // #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
25301 #undef JSON_HEDLEY_ALWAYS_INLINE
25302 #undef JSON_HEDLEY_ARM_VERSION
25303 #undef JSON_HEDLEY_ARM_VERSION_CHECK
25304 #undef JSON_HEDLEY_ARRAY_PARAM
25305 #undef JSON_HEDLEY_ASSUME
25306 #undef JSON_HEDLEY_BEGIN_C_DECLS
25307 #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE
25308 #undef JSON_HEDLEY_CLANG_HAS_BUILTIN
25309 #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE
25310 #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE
25311 #undef JSON_HEDLEY_CLANG_HAS_EXTENSION
25312 #undef JSON_HEDLEY_CLANG_HAS_FEATURE
25313 #undef JSON_HEDLEY_CLANG_HAS_WARNING
25314 #undef JSON_HEDLEY_COMPCERT_VERSION
25315 #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK
25316 #undef JSON_HEDLEY_CONCAT
25317 #undef JSON_HEDLEY_CONCAT3
25318 #undef JSON_HEDLEY_CONCAT3_EX
25319 #undef JSON_HEDLEY_CONCAT_EX
25320 #undef JSON_HEDLEY_CONST
25321 #undef JSON_HEDLEY_CONSTEXPR
25322 #undef JSON_HEDLEY_CONST_CAST
25323 #undef JSON_HEDLEY_CPP_CAST
25324 #undef JSON_HEDLEY_CRAY_VERSION
25325 #undef JSON_HEDLEY_CRAY_VERSION_CHECK
25326 #undef JSON_HEDLEY_C_DECL
25327 #undef JSON_HEDLEY_DEPRECATED
25328 #undef JSON_HEDLEY_DEPRECATED_FOR
25329 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL
25330 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_
25331 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED
25332 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES
25333 #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS
25334 #undef JSON_HEDLEY_DIAGNOSTIC_POP
25335 #undef JSON_HEDLEY_DIAGNOSTIC_PUSH
25336 #undef JSON_HEDLEY_DMC_VERSION
25337 #undef JSON_HEDLEY_DMC_VERSION_CHECK
25338 #undef JSON_HEDLEY_EMPTY_BASES
25339 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION
25340 #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK
25341 #undef JSON_HEDLEY_END_C_DECLS
25342 #undef JSON_HEDLEY_FLAGS
25343 #undef JSON_HEDLEY_FLAGS_CAST
25344 #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE
25345 #undef JSON_HEDLEY_GCC_HAS_BUILTIN
25346 #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE
25347 #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE
25348 #undef JSON_HEDLEY_GCC_HAS_EXTENSION
25349 #undef JSON_HEDLEY_GCC_HAS_FEATURE
25350 #undef JSON_HEDLEY_GCC_HAS_WARNING
25351 #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK
25352 #undef JSON_HEDLEY_GCC_VERSION
25353 #undef JSON_HEDLEY_GCC_VERSION_CHECK
25354 #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE
25355 #undef JSON_HEDLEY_GNUC_HAS_BUILTIN
25356 #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE
25357 #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE
25358 #undef JSON_HEDLEY_GNUC_HAS_EXTENSION
25359 #undef JSON_HEDLEY_GNUC_HAS_FEATURE
25360 #undef JSON_HEDLEY_GNUC_HAS_WARNING
25361 #undef JSON_HEDLEY_GNUC_VERSION
25362 #undef JSON_HEDLEY_GNUC_VERSION_CHECK
25363 #undef JSON_HEDLEY_HAS_ATTRIBUTE
25364 #undef JSON_HEDLEY_HAS_BUILTIN
25365 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE
25366 #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS
25367 #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE
25368 #undef JSON_HEDLEY_HAS_EXTENSION
25369 #undef JSON_HEDLEY_HAS_FEATURE
25370 #undef JSON_HEDLEY_HAS_WARNING
25371 #undef JSON_HEDLEY_IAR_VERSION
25372 #undef JSON_HEDLEY_IAR_VERSION_CHECK
25373 #undef JSON_HEDLEY_IBM_VERSION
25374 #undef JSON_HEDLEY_IBM_VERSION_CHECK
25375 #undef JSON_HEDLEY_IMPORT
25376 #undef JSON_HEDLEY_INLINE
25377 #undef JSON_HEDLEY_INTEL_VERSION
25378 #undef JSON_HEDLEY_INTEL_VERSION_CHECK
25379 #undef JSON_HEDLEY_IS_CONSTANT
25380 #undef JSON_HEDLEY_IS_CONSTEXPR_
25381 #undef JSON_HEDLEY_LIKELY
25382 #undef JSON_HEDLEY_MALLOC
25383 #undef JSON_HEDLEY_MESSAGE
25384 #undef JSON_HEDLEY_MSVC_VERSION
25385 #undef JSON_HEDLEY_MSVC_VERSION_CHECK
25386 #undef JSON_HEDLEY_NEVER_INLINE
25387 #undef JSON_HEDLEY_NON_NULL
25388 #undef JSON_HEDLEY_NO_ESCAPE
25389 #undef JSON_HEDLEY_NO_RETURN
25390 #undef JSON_HEDLEY_NO_THROW
25391 #undef JSON_HEDLEY_NULL
25392 #undef JSON_HEDLEY_PELLES_VERSION
25393 #undef JSON_HEDLEY_PELLES_VERSION_CHECK
25394 #undef JSON_HEDLEY_PGI_VERSION
25395 #undef JSON_HEDLEY_PGI_VERSION_CHECK
25396 #undef JSON_HEDLEY_PREDICT
25397 #undef JSON_HEDLEY_PRINTF_FORMAT
25398 #undef JSON_HEDLEY_PRIVATE
25399 #undef JSON_HEDLEY_PUBLIC
25400 #undef JSON_HEDLEY_PURE
25401 #undef JSON_HEDLEY_REINTERPRET_CAST
25402 #undef JSON_HEDLEY_REQUIRE
25403 #undef JSON_HEDLEY_REQUIRE_CONSTEXPR
25404 #undef JSON_HEDLEY_REQUIRE_MSG
25405 #undef JSON_HEDLEY_RESTRICT
25406 #undef JSON_HEDLEY_RETURNS_NON_NULL
25407 #undef JSON_HEDLEY_SENTINEL
25408 #undef JSON_HEDLEY_STATIC_ASSERT
25409 #undef JSON_HEDLEY_STATIC_CAST
25410 #undef JSON_HEDLEY_STRINGIFY
25411 #undef JSON_HEDLEY_STRINGIFY_EX
25412 #undef JSON_HEDLEY_SUNPRO_VERSION
25413 #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK
25414 #undef JSON_HEDLEY_TINYC_VERSION
25415 #undef JSON_HEDLEY_TINYC_VERSION_CHECK
25416 #undef JSON_HEDLEY_TI_ARMCL_VERSION
25417 #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK
25418 #undef JSON_HEDLEY_TI_CL2000_VERSION
25419 #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK
25420 #undef JSON_HEDLEY_TI_CL430_VERSION
25421 #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK
25422 #undef JSON_HEDLEY_TI_CL6X_VERSION
25423 #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK
25424 #undef JSON_HEDLEY_TI_CL7X_VERSION
25425 #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK
25426 #undef JSON_HEDLEY_TI_CLPRU_VERSION
25427 #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK
25428 #undef JSON_HEDLEY_TI_VERSION
25429 #undef JSON_HEDLEY_TI_VERSION_CHECK
25430 #undef JSON_HEDLEY_UNAVAILABLE
25431 #undef JSON_HEDLEY_UNLIKELY
25432 #undef JSON_HEDLEY_UNPREDICTABLE
25433 #undef JSON_HEDLEY_UNREACHABLE
25434 #undef JSON_HEDLEY_UNREACHABLE_RETURN
25435 #undef JSON_HEDLEY_VERSION
25436 #undef JSON_HEDLEY_VERSION_DECODE_MAJOR
25437 #undef JSON_HEDLEY_VERSION_DECODE_MINOR
25438 #undef JSON_HEDLEY_VERSION_DECODE_REVISION
25439 #undef JSON_HEDLEY_VERSION_ENCODE
25440 #undef JSON_HEDLEY_WARNING
25441 #undef JSON_HEDLEY_WARN_UNUSED_RESULT
25442 #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG
25443 #undef JSON_HEDLEY_FALL_THROUGH
25444 
25445 
25446 
25447 #endif // INCLUDE_NLOHMANN_JSON_HPP_
a class to store JSON values
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(typename binary_t::container_type &&init, std::uint8_t subtype)
explicitly create a binary array (with subtype)
constexpr auto get() const noexcept -> decltype(std::declval< const basic_json_t & >().template get_ptr< PointerType >())
get a pointer value (explicit)
void insert(const_iterator first, const_iterator last)
inserts elements
detail::parser_callback_t< basic_json > parser_callback_t
per-element parser callback type
bool contains(KeyT &&key) const
check the existence of an element in a JSON object
const_reverse_iterator crbegin() const noexcept
returns a const reverse iterator to the last element
const_reference operator[](const json_pointer &ptr) const
access specified element via JSON Pointer
basic_json get() const
get special-case overload
reference operator[](const json_pointer &ptr)
access specified element via JSON Pointer
ValueType value(const typename object_t::key_type &key, const ValueType &default_value) const
access specified object element with default value
constexpr bool is_number_float() const noexcept
return whether value is a floating-point number
NumberIntegerType number_integer_t
a type for a number (integer)
friend bool operator==(const_reference lhs, const_reference rhs) noexcept
comparison: equal
friend bool operator>(const ScalarType lhs, const_reference rhs) noexcept
comparison: greater than
NLOHMANN_BASIC_JSON_TPL basic_json_t
workaround type for MSVC
static bool sax_parse(InputType &&i, SAX *sax, input_format_t format=input_format_t::json, const bool strict=true, const bool ignore_comments=false)
generate SAX events
constexpr const number_integer_t * get_impl_ptr(const number_integer_t *) const noexcept
get a pointer to the value (integer number)
ReferenceType get_ref()
get a reference value (implicit)
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json parse(InputType &&i, const parser_callback_t cb=nullptr, const bool allow_exceptions=true, const bool ignore_comments=false)
deserialize from a compatible input
reference emplace_back(Args &&... args)
add an object to an array
const_iterator find(KeyT &&key) const
find an element in a JSON object
basic_json(const value_t v)
create an empty value with a given type
basic_json & operator=(basic_json other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value)
copy assignment
size_type max_size() const noexcept
returns the maximum possible number of elements
basic_json(CompatibleType &&val) noexcept(noexcept(JSONSerializer< U >::to_json(std::declval< basic_json_t & >(), std::forward< CompatibleType >(val))))
create a JSON value
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json diff(const basic_json &source, const basic_json &target, const std::string &path="")
creates a diff as a JSON patch
void erase(const size_type idx)
remove element from a JSON array given an index
const_reverse_iterator crend() const noexcept
returns a const reverse iterator to one before the first
const_reference at(const typename object_t::key_type &key) const
access specified object element with bounds checking
static iteration_proxy< iterator > iterator_wrapper(reference ref) noexcept
wrapper to access iterator member functions in range-based for
reference at(const typename object_t::key_type &key)
access specified object element with bounds checking
iterator begin() noexcept
returns an iterator to the first element
basic_json(InputIT first, InputIT last)
construct a JSON container given an iterator range
static std::vector< uint8_t > to_ubjson(const basic_json &j, const bool use_size=false, const bool use_type=false)
create a UBJSON serialization of a given JSON value
boolean_t * get_impl_ptr(boolean_t *) noexcept
get a pointer to the value (boolean)
value_t m_type
the type of the current element
string_t * get_impl_ptr(string_t *) noexcept
get a pointer to the value (string)
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json array(initializer_list_t init={})
explicitly create an array from an initializer list
const_reverse_iterator rend() const noexcept
returns a const reverse iterator to one before the first
const_iterator cend() const noexcept
returns a const iterator to one past the last element
reference back()
access the last element
static bool accept(InputType &&i, const bool ignore_comments=false)
check if the input is valid JSON
StringType string_t
a type for a string
size_type size() const noexcept
returns the number of elements
void push_back(const basic_json &val)
add an object to an array
friend std::ostream & operator>>(const basic_json &j, std::ostream &o)
serialize to stream
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json meta()
returns version information on the library
ValueType value(const json_pointer &ptr, const ValueType &default_value) const
access specified object element via JSON Pointer with default value
void update(const_reference j)
updates a JSON object from another object, overwriting existing keys
constexpr const binary_t * get_impl_ptr(const binary_t *) const noexcept
get a pointer to the value (binary)
std::size_t size_type
a type to represent container sizes
array_t * get_impl_ptr(array_t *) noexcept
get a pointer to the value (array)
std::ptrdiff_t difference_type
a type to represent differences between iterators
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(const typename binary_t::container_type &init)
explicitly create a binary array (without subtype)
reference operator[](const typename object_t::key_type &key)
access specified object element
number_float_t * get_impl_ptr(number_float_t *) noexcept
get a pointer to the value (floating-point number)
reference operator+=(basic_json &&val)
add an object to an array
basic_json(const BasicJsonType &val)
create a JSON value from an existing one
typename std::allocator_traits< allocator_type >::const_pointer const_pointer
the type of an element const pointer
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bson(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)
friend bool operator>(const_reference lhs, const ScalarType rhs) noexcept
comparison: greater than
typename std::allocator_traits< allocator_type >::pointer pointer
the type of an element pointer
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor(InputType &&i, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
create a JSON value from an input in CBOR format
BooleanType boolean_t
a type for a boolean
void push_back(initializer_list_t init)
add an object to an object
JSON_HEDLEY_RETURNS_NON_NULL const char * type_name() const noexcept
return the type as string
boolean_t get_impl(boolean_t *) const
get a boolean (explicit)
string_t dump(const int indent=-1, const char indent_char=' ', const bool ensure_ascii=false, const error_handler_t error_handler=error_handler_t::strict) const
serialization
IteratorType erase(IteratorType pos)
remove element given an iterator
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_bson(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
Create a JSON value from an input in BSON format.
constexpr bool is_structured() const noexcept
return whether type is structured
const_iterator begin() const noexcept
returns a const iterator to the first element
iteration_proxy< const_iterator > items() const noexcept
helper to access iterator member functions in range-based for
reference at(size_type idx)
access specified array element with bounds checking
reference front()
access the first element
constexpr bool is_primitive() const noexcept
return whether type is primitive
constexpr bool is_number_unsigned() const noexcept
return whether value is an unsigned integer number
detail::cbor_tag_handler_t cbor_tag_handler_t
how to treat CBOR tags
void swap(object_t &other)
exchanges the values
constexpr bool is_object() const noexcept
return whether value is an object
const_reference front() const
access the first element
binary_t * get_impl_ptr(binary_t *) noexcept
get a pointer to the value (binary)
constexpr value_t type() const noexcept
return the type of the JSON value (explicit)
NumberFloatType number_float_t
a type for a number (floating-point)
json_reverse_iterator< typename basic_json::iterator > reverse_iterator
a reverse iterator for a basic_json container
friend bool operator<=(const_reference lhs, const_reference rhs) noexcept
comparison: less than or equal
bool empty() const noexcept
checks whether the container is empty.
constexpr const number_unsigned_t * get_impl_ptr(const number_unsigned_t *) const noexcept
get a pointer to the value (unsigned number)
friend std::ostream & operator<<(std::ostream &o, const basic_json &j)
serialize to stream
friend bool operator>=(const ScalarType lhs, const_reference rhs) noexcept
comparison: greater than or equal
basic_json(const basic_json &other)
copy constructor
constexpr const boolean_t * get_impl_ptr(const boolean_t *) const noexcept
get a pointer to the value (boolean)
~basic_json() noexcept
destructor
BasicJsonType get() const
get special-case overload
basic_json(basic_json &&other) noexcept
move constructor
static void to_bson(const basic_json &j, detail::output_adapter< uint8_t > o)
Serializes the given JSON object j to BSON and forwards the corresponding BSON-representation to the ...
friend bool operator>=(const_reference lhs, const ScalarType rhs) noexcept
comparison: greater than or equal
friend bool operator!=(const_reference lhs, const_reference rhs) noexcept
comparison: not equal
iterator insert(const_iterator pos, size_type cnt, const basic_json &val)
inserts elements
json_value m_value
the value of the current element
void swap(typename binary_t::container_type &other)
friend bool operator>=(const_reference lhs, const_reference rhs) noexcept
comparison: greater than or equal
constexpr const object_t * get_impl_ptr(const object_t *) const noexcept
get a pointer to the value (object)
void swap(array_t &other)
exchanges the values
friend bool operator<(const_reference lhs, const ScalarType rhs) noexcept
comparison: less than
reverse_iterator rend() noexcept
returns an iterator to the reverse-end
friend bool operator<=(const_reference lhs, const ScalarType rhs) noexcept
comparison: less than or equal
ReferenceType get_ref() const
get a reference value (implicit)
iterator insert(const_iterator pos, const_iterator first, const_iterator last)
inserts elements
auto get() noexcept -> decltype(std::declval< basic_json_t & >().template get_ptr< PointerType >())
get a pointer value (explicit)
const_reference at(const json_pointer &ptr) const
access specified element via JSON Pointer
const_iterator end() const noexcept
returns a const iterator to one past the last element
void merge_patch(const basic_json &apply_patch)
applies a JSON Merge Patch
auto get_ptr() noexcept -> decltype(std::declval< basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
iterator insert(const_iterator pos, initializer_list_t ilist)
inserts elements
ArrayType< basic_json, AllocatorType< basic_json > > array_t
a type for an array
friend bool operator>(const_reference lhs, const_reference rhs) noexcept
comparison: greater than
IteratorType erase(IteratorType first, IteratorType last)
remove elements given an iterator range
object_t * get_impl_ptr(object_t *) noexcept
get a pointer to the value (object)
ValueType get() const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), std::declval< ValueType & >())))
get a value (explicit)
constexpr bool is_boolean() const noexcept
return whether value is a boolean
iteration_proxy< iterator > items() noexcept
helper to access iterator member functions in range-based for
iterator end() noexcept
returns an iterator to one past the last element
void swap(reference other) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value)
exchanges the values
void clear() noexcept
clears the contents
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_msgpack(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)
constexpr bool is_binary() const noexcept
return whether value is a binary array
static std::vector< uint8_t > to_msgpack(const basic_json &j)
create a MessagePack serialization of a given JSON value
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json object(initializer_list_t init={})
explicitly create an object from an initializer list
constexpr const number_float_t * get_impl_ptr(const number_float_t *) const noexcept
get a pointer to the value (floating-point number)
iterator insert(const_iterator pos, basic_json &&val)
inserts element
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_ubjson(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true)
reference operator[](size_type idx)
access specified array element
static void to_bson(const basic_json &j, detail::output_adapter< char > o)
Serializes the given JSON object j to BSON and forwards the corresponding BSON-representation to the ...
void update(const_iterator first, const_iterator last)
updates a JSON object from another object, overwriting existing keys
reference at(const json_pointer &ptr)
access specified element via JSON Pointer
ValueType & get_to(ValueType &v) const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >(), v)))
get a value (explicit)
void swap(binary_t &other)
exchanges the values
static std::vector< uint8_t > to_bson(const basic_json &j)
Serializes the given JSON object j to BSON and returns a vector containing the corresponding BSON-rep...
json_reverse_iterator< typename basic_json::const_iterator > const_reverse_iterator
a const reverse iterator for a basic_json container
void assert_invariant() const noexcept
checks the class invariants
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_ubjson(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in UBJSON format
::nlohmann::json_pointer< basic_json > json_pointer
JSON Pointer, see nlohmann::json_pointer.
number_unsigned_t * get_impl_ptr(number_unsigned_t *) noexcept
get a pointer to the value (unsigned number)
const_reverse_iterator rbegin() const noexcept
returns a const reverse iterator to the last element
void swap(string_t &other)
exchanges the values
const_reference back() const
access the last element
friend bool operator<(const_reference lhs, const_reference rhs) noexcept
comparison: less than
friend std::istream & operator>>(std::istream &i, basic_json &j)
deserialize from stream
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(typename binary_t::container_type &&init)
explicitly create a binary array (without subtype)
friend bool operator!=(const ScalarType lhs, const_reference rhs) noexcept
comparison: not equal
constexpr bool is_string() const noexcept
return whether value is a string
number_integer_t * get_impl_ptr(number_integer_t *) noexcept
get a pointer to the value (integer number)
constexpr bool is_array() const noexcept
return whether value is an array
iterator insert_iterator(const_iterator pos, Args &&... args)
basic_json flatten() const
return flattened JSON value
void push_back(basic_json &&val)
add an object to an array
friend bool operator==(const_reference lhs, const ScalarType rhs) noexcept
comparison: equal
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_cbor(IteratorType first, IteratorType last, const bool strict=true, const bool allow_exceptions=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
size_type count(KeyT &&key) const
returns the number of occurrences of a key in a JSON object
const binary_t & get_binary() const
constexpr bool is_number() const noexcept
return whether value is a number
friend bool operator<(const ScalarType lhs, const_reference rhs) noexcept
comparison: less than
std::pair< iterator, bool > emplace(Args &&... args)
add an object to an object if key does not exist
reference operator+=(initializer_list_t init)
add an object to an object
constexpr bool is_number_integer() const noexcept
return whether value is an integer number
static JSON_HEDLEY_RETURNS_NON_NULL T * create(Args &&... args)
helper for exception-safe object creation
std::initializer_list< detail::json_ref< basic_json > > initializer_list_t
helper type for initializer lists of basic_json values
constexpr const array_t * get_impl_ptr(const array_t *) const noexcept
get a pointer to the value (array)
const_reference operator[](const typename object_t::key_type &key) const
read-only access specified object element
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json binary(const typename binary_t::container_type &init, std::uint8_t subtype)
explicitly create a binary array (with subtype)
iterator find(KeyT &&key)
find an element in a JSON object
basic_json(std::nullptr_t=nullptr) noexcept
create a null object
const_reference operator[](size_type idx) const
access specified array element
AllocatorType< basic_json > allocator_type
the allocator type
nlohmann::byte_container_with_subtype< BinaryType > binary_t
a type for a packed binary type
void push_back(const typename object_t::value_type &val)
add an object to an object
friend bool operator<=(const ScalarType lhs, const_reference rhs) noexcept
comparison: less than or equal
ValueType get() const noexcept(noexcept(JSONSerializer< ValueType >::from_json(std::declval< const basic_json_t & >())))
get a value (explicit); special case
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json parse(IteratorType first, IteratorType last, const parser_callback_t cb=nullptr, const bool allow_exceptions=true, const bool ignore_comments=false)
deserialize from a pair of character iterators
constexpr const string_t * get_impl_ptr(const string_t *) const noexcept
get a pointer to the value (string)
static std::vector< uint8_t > to_cbor(const basic_json &j)
create a CBOR serialization of a given JSON value
bool contains(const json_pointer &ptr) const
check the existence of an element in a JSON object given a JSON pointer
static JSON_HEDLEY_WARN_UNUSED_RESULT basic_json from_msgpack(InputType &&i, const bool strict=true, const bool allow_exceptions=true)
create a JSON value from an input in MessagePack format
basic_json patch(const basic_json &json_patch) const
applies a JSON patch
string_t value(const typename object_t::key_type &key, const char *default_value) const
overload for a default value of type const char*
basic_json unflatten() const
unflatten a previously flattened JSON value
NumberUnsignedType number_unsigned_t
a type for a number (unsigned)
reference operator+=(const typename object_t::value_type &val)
add an object to an object
const_iterator cbegin() const noexcept
returns a const iterator to the first element
basic_json(initializer_list_t init, bool type_deduction=true, value_t manual_type=value_t::array)
create a container (array or object) from an initializer list
const_reference at(size_type idx) const
access specified array element with bounds checking
iterator insert(const_iterator pos, const basic_json &val)
inserts element
constexpr bool is_discarded() const noexcept
return whether value is discarded
constexpr bool is_null() const noexcept
return whether value is null
friend void swap(reference left, reference right) noexcept(std::is_nothrow_move_constructible< value_t >::value &&std::is_nothrow_move_assignable< value_t >::value &&std::is_nothrow_move_constructible< json_value >::value &&std::is_nothrow_move_assignable< json_value >::value)
exchanges the values
friend bool operator==(const ScalarType lhs, const_reference rhs) noexcept
comparison: equal
ObjectType< StringType, basic_json, object_comparator_t, AllocatorType< std::pair< const StringType, basic_json > >> object_t
a type for an object
reference operator+=(const basic_json &val)
add an object to an array
size_type erase(const typename object_t::key_type &key)
remove element from a JSON object given a key
static ReferenceType get_ref_impl(ThisType &obj)
helper function to implement get_ref()
basic_json(size_type cnt, const basic_json &val)
construct an array with count copies of given value
static allocator_type get_allocator()
returns the allocator associated with the container
constexpr auto get_ptr() const noexcept -> decltype(std::declval< const basic_json_t & >().get_impl_ptr(std::declval< PointerType >()))
get a pointer value (implicit)
friend bool operator!=(const_reference lhs, const ScalarType rhs) noexcept
comparison: not equal
reverse_iterator rbegin() noexcept
returns an iterator to the reverse-beginning
an internal type for a backed binary type
BinaryType container_type
the type of the underlying container
void clear_subtype() noexcept
clears the binary subtype
constexpr bool has_subtype() const noexcept
return whether the value has a subtype
void set_subtype(std::uint8_t subtype) noexcept
sets the binary subtype
constexpr std::uint8_t subtype() const noexcept
return the binary subtype
deserialization of CBOR, MessagePack, and UBJSON values
bool get_msgpack_array(const std::size_t len)
bool get_bson_string(const NumberType len, string_t &result)
Parses a zero-terminated string of length len from the BSON input.
bool parse_bson_element_internal(const char_int_type element_type, const std::size_t element_type_parse_position)
Read a BSON document element of the given element_type.
bool parse_bson_array()
Reads an array from the BSON input and passes it to the SAX-parser.
bool get_bson_cstr(string_t &result)
Parses a C-style string from the BSON input.
bool get_cbor_array(const std::size_t len, const cbor_tag_handler_t tag_handler)
bool get_msgpack_binary(binary_t &result)
reads a MessagePack byte array
bool get_cbor_object(const std::size_t len, const cbor_tag_handler_t tag_handler)
bool get_ubjson_string(string_t &result, const bool get_char=true)
reads a UBJSON string
bool parse_bson_element_list(const bool is_array)
Read a BSON element list (as specified in the BSON-spec)
bool parse_cbor_internal(const bool get_char, const cbor_tag_handler_t tag_handler)
bool get_string(const input_format_t format, const NumberType len, string_t &result)
create a string by reading characters from the input
bool get_cbor_string(string_t &result)
reads a CBOR string
InputAdapterType ia
input adapter
bool get_binary(const input_format_t format, const NumberType len, binary_t &result)
create a byte array by reading bytes from the input
bool parse_ubjson_internal(const bool get_char=true)
bool unexpect_eof(const input_format_t format, const char *context) const
bool get_ubjson_size_type(std::pair< std::size_t, char_int_type > &result)
determine the type and size for a container
std::string get_token_string() const
bool get_ubjson_value(const char_int_type prefix)
bool get_msgpack_object(const std::size_t len)
bool get_bson_binary(const NumberType len, binary_t &result)
Parses a byte array input of length len from the BSON input.
std::string exception_message(const input_format_t format, const std::string &detail, const std::string &context) const
std::size_t chars_read
the number of characters read
char_int_type current
the current character
bool sax_parse(const input_format_t format, json_sax_t *sax_, const bool strict=true, const cbor_tag_handler_t tag_handler=cbor_tag_handler_t::error)
json_sax_t * sax
the SAX parser
bool get_ubjson_size_value(std::size_t &result)
bool parse_bson_internal()
Reads in a BSON-object and passes it to the SAX-parser.
bool get_cbor_binary(binary_t &result)
reads a CBOR byte array
char_int_type get()
get next character from the input
const bool is_little_endian
whether we can assume little endianess
binary_reader(InputAdapterType &&adapter)
create a binary reader
bool get_msgpack_string(string_t &result)
reads a MessagePack string
serialization to CBOR and MessagePack values
void write_bson_array(const string_t &name, const typename BasicJsonType::array_t &value)
Writes a BSON element with key name and array value.
const bool is_little_endian
whether we can assume little endianess
void write_ubjson(const BasicJsonType &j, const bool use_count, const bool use_type, const bool add_prefix=true)
void write_bson_entry_header(const string_t &name, const std::uint8_t element_type)
Writes the given element_type and name to the output adapter.
static std::size_t calc_bson_element_size(const string_t &name, const BasicJsonType &j)
Calculates the size necessary to serialize the JSON value j with its name.
void write_bson_double(const string_t &name, const double value)
Writes a BSON element with key name and double value value.
void write_bson_object(const typename BasicJsonType::object_t &value)
binary_writer(output_adapter_t< CharType > adapter)
create a binary writer
CharType ubjson_prefix(const BasicJsonType &j) const noexcept
determine the type prefix of container values
void write_bson_integer(const string_t &name, const std::int64_t value)
Writes a BSON element with key name and integer value.
static std::size_t calc_bson_entry_header_size(const string_t &name)
void write_bson_unsigned(const string_t &name, const std::uint64_t value)
Writes a BSON element with key name and unsigned value.
void write_bson_string(const string_t &name, const string_t &value)
Writes a BSON element with key name and string value value.
void write_bson_object_entry(const string_t &name, const typename BasicJsonType::object_t &value)
Writes a BSON element with key name and object value.
output_adapter_t< CharType > oa
the output
void write_bson_element(const string_t &name, const BasicJsonType &j)
Serializes the JSON value j to BSON and associates it with the key name.
void write_bson_binary(const string_t &name, const binary_t &value)
Writes a BSON element with key name and binary value value.
void write_bson_null(const string_t &name)
Writes a BSON element with key name and null value.
static std::size_t calc_bson_binary_size(const typename BasicJsonType::binary_t &value)
void write_bson(const BasicJsonType &j)
void write_cbor(const BasicJsonType &j)
static constexpr std::size_t calc_bson_unsigned_size(const std::uint64_t value) noexcept
static std::size_t calc_bson_object_size(const typename BasicJsonType::object_t &value)
Calculates the size of the BSON serialization of the given JSON-object j.
void write_bson_boolean(const string_t &name, const bool value)
Writes a BSON element with key name and boolean value value.
void write_msgpack(const BasicJsonType &j)
static std::size_t calc_bson_string_size(const string_t &value)
static std::size_t calc_bson_integer_size(const std::int64_t value)
static std::size_t calc_bson_array_size(const typename BasicJsonType::array_t &value)
general exception of the basic_json class
const int id
the id of the exception
JSON_HEDLEY_RETURNS_NON_NULL const char * what() const noexcept override
returns the explanatory string
std::runtime_error m
an exception object as storage for error messages
std::FILE * m_file
the file pointer to read from
std::istream * is
the associated input stream
exception indicating errors with iterators
a template for a bidirectional iterator for the basic_json class This class implements a both iterato...
bool operator<(const iter_impl &other) const
comparison: smaller
iter_impl operator-(difference_type i) const
subtract from iterator
const object_t::key_type & key() const
return the key of an object iterator
iter_impl()=default
default constructor
iter_impl const operator--(int)
post-decrement (it–)
void set_end() noexcept
set the iterator past the last value
bool operator==(const iter_impl &other) const
comparison: equal
typename BasicJsonType::difference_type difference_type
a type to represent differences between iterators
iter_impl & operator+=(difference_type i)
add to iterator
difference_type operator-(const iter_impl &other) const
return difference
typename std::conditional< std::is_const< BasicJsonType >::value, typename BasicJsonType::const_reference, typename BasicJsonType::reference >::type reference
defines a reference to the type iterated over (value_type)
reference operator*() const
return a reference to the value pointed to by the iterator
void set_begin() noexcept
set the iterator to the first value
bool operator>=(const iter_impl &other) const
comparison: greater than or equal
typename std::conditional< std::is_const< BasicJsonType >::value, typename BasicJsonType::const_pointer, typename BasicJsonType::pointer >::type pointer
defines a pointer to the type iterated over (value_type)
pointer operator->() const
dereference the iterator
iter_impl & operator=(const iter_impl< typename std::remove_const< BasicJsonType >::type > &other) noexcept
converting assignment
iter_impl(const iter_impl< const BasicJsonType > &other) noexcept
const copy constructor
iter_impl const operator++(int)
post-increment (it++)
iter_impl & operator--()
pre-decrement (–it)
iter_impl(const iter_impl< typename std::remove_const< BasicJsonType >::type > &other) noexcept
converting constructor
iter_impl(pointer object) noexcept
constructor for a given JSON instance
internal_iterator< typename std::remove_const< BasicJsonType >::type > m_it
the actual iterator of the associated instance
iter_impl operator+(difference_type i) const
add to iterator
friend iter_impl operator+(difference_type i, const iter_impl &it)
addition of distance and iterator
iter_impl & operator=(const iter_impl< const BasicJsonType > &other) noexcept
converting assignment
bool operator>(const iter_impl &other) const
comparison: greater than
typename BasicJsonType::value_type value_type
the type of the values when the iterator is dereferenced
reference value() const
return the value of an iterator
iter_impl & operator-=(difference_type i)
subtract from iterator
iter_impl & operator++()
pre-increment (++it)
reference operator[](difference_type n) const
access to successor
bool operator<=(const iter_impl &other) const
comparison: less than or equal
pointer m_object
associated JSON instance
std::bidirectional_iterator_tag iterator_category
bool operator!=(const iter_impl &other) const
comparison: not equal
iteration_proxy_value & operator*()
dereference operator (needed for range-based for)
const string_type empty_str
an empty string (to return a reference for primitive values)
bool operator!=(const iteration_proxy_value &o) const
inequality operator (needed for range-based for)
std::size_t array_index_last
last stringified array index
string_type array_index_str
a string representation of the array index
IteratorType::reference value() const
return value of the iterator
std::size_t array_index
an index for arrays (used to create key names)
iteration_proxy_value & operator++()
increment operator (needed for range-based for)
const string_type & key() const
return key of the iterator
bool operator==(const iteration_proxy_value &o) const
equality operator (needed for InputIterator)
proxy class for the items() function
iteration_proxy_value< IteratorType > begin() noexcept
return iterator begin (needed for range-based for)
IteratorType::reference container
the container to iterate
iteration_proxy_value< IteratorType > end() noexcept
return iterator end (needed for range-based for)
iteration_proxy(typename IteratorType::reference cont) noexcept
construct iteration proxy from a container
a template for a reverse iterator class
json_reverse_iterator(const typename base_iterator::iterator_type &it) noexcept
create reverse iterator from iterator
json_reverse_iterator & operator--()
pre-decrement (–it)
json_reverse_iterator & operator++()
pre-increment (++it)
json_reverse_iterator const operator--(int)
post-decrement (it–)
typename Base::reference reference
the reference type for the pointed-to element
json_reverse_iterator & operator+=(difference_type i)
add to iterator
json_reverse_iterator operator-(difference_type i) const
subtract from iterator
std::reverse_iterator< Base > base_iterator
shortcut to the reverse iterator adapter
json_reverse_iterator(const base_iterator &it) noexcept
create reverse iterator from base class
reference operator[](difference_type n) const
access to successor
difference_type operator-(const json_reverse_iterator &other) const
return difference
json_reverse_iterator operator+(difference_type i) const
add to iterator
json_reverse_iterator const operator++(int)
post-increment (it++)
auto key() const -> decltype(std::declval< Base >().key())
return the key of an object iterator
reference value() const
return the value of an iterator
const bool allow_exceptions
whether to throw exceptions in case of errors
BasicJsonType * object_element
helper to hold the reference for the next object element
const parser_callback_t callback
callback function
BasicJsonType & root
the parsed JSON value
std::vector< BasicJsonType * > ref_stack
stack to model hierarchy of values
std::pair< bool, BasicJsonType * > handle_value(Value &&v, const bool skip_callback=false)
BasicJsonType discarded
a discarded value for the callback
std::vector< bool > key_keep_stack
stack to manage which object keys to keep
bool errored
whether a syntax error occurred
std::vector< bool > keep_stack
stack to manage which values to keep
SAX implementation to create a JSON value from SAX events.
bool errored
whether a syntax error occurred
BasicJsonType * object_element
helper to hold the reference for the next object element
JSON_HEDLEY_RETURNS_NON_NULL BasicJsonType * handle_value(Value &&v)
std::vector< BasicJsonType * > ref_stack
stack to model hierarchy of values
const bool allow_exceptions
whether to throw exceptions in case of errors
BasicJsonType & root
the parsed JSON value
json_sax_dom_parser(BasicJsonType &r, const bool allow_exceptions_=true)
token_type
token types for the parser
@ value_float
an floating point number – use get_number_float() for actual value
@ begin_array
the character for array begin [
@ value_string
a string – use get_string() for actual value
@ end_array
the character for array end ]
@ uninitialized
indicating the scanner is uninitialized
@ parse_error
indicating a parse error
@ value_integer
a signed integer – use get_number_integer() for actual value
@ value_separator
the value separator ,
@ end_object
the character for object end }
@ begin_object
the character for object begin {
@ value_unsigned
an unsigned integer – use get_number_unsigned() for actual value
@ end_of_input
indicating the end of the input buffer
@ literal_or_value
a literal or the begin of a value (only for diagnostics)
JSON_HEDLEY_RETURNS_NON_NULL static JSON_HEDLEY_CONST const char * token_type_name(const token_type t) noexcept
return name of values of type token_type (only used for errors)
const bool ignore_comments
whether comments should be ignored (true) or signaled as errors (false)
void add(char_int_type c)
add a character to token_buffer
void reset() noexcept
reset token_buffer; current character is beginning of token
bool next_unget
whether the next get() call should just return current
char_int_type current
the current character
static JSON_HEDLEY_PURE char get_decimal_point() noexcept
return the locale-dependent decimal point
InputAdapterType ia
input adapter
const char_int_type decimal_point_char
the decimal point
string_t & get_string()
return current string value (implicitly resets the token; useful only once)
bool skip_bom()
skip the UTF-8 byte order mark
const char * error_message
a description of occurred lexer errors
position_t position
the start position of the current token
constexpr position_t get_position() const noexcept
return position of last read token
std::vector< char_type > token_string
raw input token string (for error messages)
constexpr number_integer_t get_number_integer() const noexcept
return integer value
constexpr JSON_HEDLEY_RETURNS_NON_NULL const char * get_error_message() const noexcept
return syntax error message
token_type scan_number()
scan a number literal
void unget()
unget current character (read it again on next get)
token_type scan_string()
scan a string literal
constexpr number_unsigned_t get_number_unsigned() const noexcept
return unsigned integer value
string_t token_buffer
buffer for variable-length tokens (numbers, strings)
token_type scan_literal(const char_type *literal_text, const std::size_t length, token_type return_type)
constexpr number_float_t get_number_float() const noexcept
return floating-point value
int get_codepoint()
get codepoint from 4 hex characters following \u
std::string get_token_string() const
bool next_byte_in_range(std::initializer_list< char_int_type > ranges)
check if the next byte(s) are inside a given range
bool scan_comment()
scan a comment
exception indicating other library errors
exception indicating access out of the defined range
output adapter for output streams
output adapter for basic_string
output adapter for byte vectors
exception indicating a parse error
static parse_error create(int id_, const position_t &pos, const std::string &what_arg)
create a parse error exception
const std::size_t byte
byte index of the parse error
token_type get_token()
get next token from lexer
token_type last_token
the type of the last read token
parser(InputAdapterType &&adapter, const parser_callback_t< BasicJsonType > cb=nullptr, const bool allow_exceptions_=true, const bool skip_comments=false)
a parser reading from an input adapter
bool accept(const bool strict=true)
public accept interface
const parser_callback_t< BasicJsonType > callback
callback function
void parse(const bool strict, BasicJsonType &result)
public parser interface
const bool allow_exceptions
whether to throw exceptions in case of errors
difference_type m_it
iterator as signed integer type
constexpr bool is_end() const noexcept
return whether the iterator is at end
constexpr bool is_begin() const noexcept
return whether the iterator can be dereferenced
void set_begin() noexcept
set iterator to a defined beginning
void set_end() noexcept
set iterator to a defined past the end
const error_handler_t error_handler
error_handler how to react on decoding errors
unsigned int count_digits(number_unsigned_t x) noexcept
count digits
const std::lconv * loc
the locale
std::array< char, 64 > number_buffer
a (hopefully) large enough character buffer
const char decimal_point
the locale's decimal point character
void dump_float(number_float_t x)
dump a floating-point number
const char thousands_sep
the locale's thousand separator character
void dump_integer(NumberType x)
dump an integer
void dump(const BasicJsonType &val, const bool pretty_print, const bool ensure_ascii, const unsigned int indent_step, const unsigned int current_indent=0)
internal implementation of the serialization function
const char indent_char
the indentation character
std::array< char, 512 > string_buffer
string buffer
static std::uint8_t decode(std::uint8_t &state, std::uint32_t &codep, const std::uint8_t byte) noexcept
check whether a string is UTF-8 encoded
serializer(output_adapter_t< char > s, const char ichar, error_handler_t error_handler_=error_handler_t::strict)
void dump_escaped(const string_t &s, const bool ensure_ascii)
dump escaped string
output_adapter_t< char > o
the output of the serializer
string_t indent_string
the indentation string
exception indicating executing a member function with a wrong type
std::size_t utf8_bytes_index
index to the utf8_codes array for the next valid byte
std::size_t utf8_bytes_filled
number of valid bytes in the utf8_codes array
std::array< std::char_traits< char >::int_type, 4 > utf8_bytes
a buffer for UTF-8 bytes
std::vector< std::string > reference_tokens
the reference tokens
const std::string & back() const
return last reference token
BasicJsonType & get_checked(BasicJsonType *ptr) const
std::string to_string() const
return a string representation of the JSON pointer
friend bool operator==(json_pointer const &lhs, json_pointer const &rhs) noexcept
compares two JSON pointers for equality
void pop_back()
remove last reference token
const BasicJsonType & get_checked(const BasicJsonType *ptr) const
BasicJsonType & get_unchecked(BasicJsonType *ptr) const
return a reference to the pointed to value
BasicJsonType & get_and_create(BasicJsonType &j) const
create and return a reference to the pointed to value
bool empty() const noexcept
return whether pointer points to the root document
friend bool operator!=(json_pointer const &lhs, json_pointer const &rhs) noexcept
compares two JSON pointers for inequality
void push_back(const std::string &token)
append an unescaped token at the end of the reference pointer
json_pointer & operator/=(const json_pointer &ptr)
append another JSON pointer at the end of this JSON pointer
json_pointer & operator/=(std::size_t array_idx)
append an array index at the end of this JSON pointer
json_pointer(const std::string &s="")
create JSON pointer
static std::string escape(std::string s)
escape "~" to "~0" and "/" to "~1"
friend json_pointer operator/(const json_pointer &lhs, const json_pointer &rhs)
create a new JSON pointer by appending the right JSON pointer at the end of the left JSON pointer
bool contains(const BasicJsonType *ptr) const
static BasicJsonType unflatten(const BasicJsonType &value)
friend json_pointer operator/(const json_pointer &ptr, std::string token)
create a new JSON pointer by appending the unescaped token at the end of the JSON pointer
static void replace_substring(std::string &s, const std::string &f, const std::string &t)
replace all occurrences of a substring by another string
static void flatten(const std::string &reference_string, const BasicJsonType &value, BasicJsonType &result)
static void unescape(std::string &s)
unescape "~1" to tilde and "~0" to slash (order is important!)
json_pointer & operator/=(std::string token)
append an unescaped reference token at the end of this JSON pointer
void push_back(std::string &&token)
append an unescaped token at the end of the reference pointer
const BasicJsonType & get_unchecked(const BasicJsonType *ptr) const
return a const reference to the pointed to value
static std::vector< std::string > split(const std::string &reference_string)
split the string input to reference tokens
static BasicJsonType::size_type array_index(const std::string &s)
friend json_pointer operator/(const json_pointer &ptr, std::size_t array_idx)
create a new JSON pointer by appending the array-index-token at the end of the JSON pointer
json_pointer parent_pointer() const
returns the parent of this JSON pointer
void deallocate(void *ptr__)
Deallocate GPU memory.
Definition: acc.hpp:406
acc_stream_t stream(stream_id sid__)
Return a single device stream.
Definition: acc.hpp:177
T * allocate(size_t size__)
Allocate memory on the GPU.
Definition: acc.hpp:388
void grisu2(char *buf, int &len, int &decimal_exponent, diyfp m_minus, diyfp v, diyfp m_plus)
boundaries compute_boundaries(FloatType value)
int find_largest_pow10(const std::uint32_t n, std::uint32_t &pow10)
void grisu2_digit_gen(char *buffer, int &length, int &decimal_exponent, diyfp M_minus, diyfp w, diyfp M_plus)
JSON_HEDLEY_RETURNS_NON_NULL char * format_buffer(char *buf, int len, int decimal_exponent, int min_exp, int max_exp)
prettify v = buf * 10^decimal_exponent
JSON_HEDLEY_RETURNS_NON_NULL char * append_exponent(char *buf, int e)
appends a decimal representation of e to buf
cached_power get_cached_power_for_binary_exponent(int e)
bool operator<(const value_t lhs, const value_t rhs) noexcept
comparison operator for JSON types
value_t
the JSON type enumeration
@ number_integer
number value (signed integer)
@ discarded
discarded by the parser callback function
@ binary
binary array (ordered collection of bytes)
@ object
object (unordered set of name/value pairs)
@ number_float
number value (floating-point)
@ number_unsigned
number value (unsigned integer)
@ array
array (ordered collection of values)
@ value
the parser finished reading a JSON value
@ key
the parser read a key of a value in an object
@ array_end
the parser read ] and finished processing a JSON array
@ array_start
the parser read [ and started to process a JSON array
@ object_start
the parser read { and started to process a JSON object
@ object_end
the parser read } and finished processing a JSON object
cbor_tag_handler_t
how to treat CBOR tags
@ error
throw a parse_error exception in case of a tag
error_handler_t
how to treat decoding errors
@ strict
throw a type_error exception in case of invalid UTF-8
@ ignore
ignore invalid UTF-8 sequences
@ replace
replace invalid UTF-8 sequences with U+FFFD
std::size_t hash(const BasicJsonType &j)
hash a JSON value
JSON_HEDLEY_RETURNS_NON_NULL char * to_chars(char *first, const char *last, FloatType value)
generates a decimal representation of the floating-point number value in [first, last).
std::shared_ptr< output_adapter_protocol< CharType > > output_adapter_t
a type to simplify interfaces
input_format_t
the supported input formats
static bool little_endianess(int num=1) noexcept
determine system byte order
namespace for Niels Lohmann
NLOHMANN_BASIC_JSON_TPL_DECLARATION std::string to_string(const NLOHMANN_BASIC_JSON_TPL &j)
user-defined to_string function for JSON values
Spheric_function< domain_t, T > operator+(Spheric_function< domain_t, T > const &a__, Spheric_function< domain_t, T > const &b__)
Summation of two functions.
Spheric_function< domain_t, T > operator-(Spheric_function< domain_t, T > const &a__, Spheric_function< domain_t, T > const &b__)
Subtraction of functions.
uint64_t hash(void const *buff, size_t size, uint64_t h=5381)
Simple hash function.
Definition: utils.hpp:249
default JSONSerializer template argument
static auto to_json(BasicJsonType &j, ValueType &&val) noexcept(noexcept(::nlohmann::to_json(j, std::forward< ValueType >(val)))) -> decltype(::nlohmann::to_json(j, std::forward< ValueType >(val)), void())
convert any value type to a JSON value
static auto from_json(BasicJsonType &&j, ValueType &val) noexcept(noexcept(::nlohmann::from_json(std::forward< BasicJsonType >(j), val))) -> decltype(::nlohmann::from_json(std::forward< BasicJsonType >(j), val), void())
convert a JSON value to any value type
static diyfp normalize(diyfp x) noexcept
normalize x such that the significand is >= 2^(q-1)
static diyfp normalize_to(const diyfp &x, const int target_exponent) noexcept
normalize x such that the result has the exponent E
static diyfp mul(const diyfp &x, const diyfp &y) noexcept
returns x * y
static diyfp sub(const diyfp &x, const diyfp &y) noexcept
returns x - y
primitive_iterator_t primitive_iterator
generic iterator for all other types
BasicJsonType::array_t::iterator array_iterator
iterator for JSON arrays
BasicJsonType::object_t::iterator object_iterator
iterator for JSON objects
abstract output adapter interface
struct to capture the start position of the current token
std::size_t lines_read
the number of lines read
std::size_t chars_read_current_line
the number of characters read in the current line
std::size_t chars_read_total
the total number of characters read
virtual bool start_object(std::size_t elements)=0
the beginning of an object was read
virtual bool string(string_t &val)=0
a string was read
virtual bool end_array()=0
the end of an array was read
virtual bool key(string_t &val)=0
an object key was read
virtual bool binary(binary_t &val)=0
a binary string was read
virtual bool start_array(std::size_t elements)=0
the beginning of an array was read
virtual bool parse_error(std::size_t position, const std::string &last_token, const detail::exception &ex)=0
a parse error occurred
virtual bool boolean(bool val)=0
a boolean value was read
virtual bool end_object()=0
the end of an object was read
virtual bool number_unsigned(number_unsigned_t val)=0
an unsigned integer number was read
virtual bool number_float(number_float_t val, const string_t &s)=0
an floating-point number was read
virtual bool number_integer(number_integer_t val)=0
an integer number was read
std::size_t operator()(const nlohmann::json &j) const
return a hash value for a JSON object
bool operator()(nlohmann::detail::value_t lhs, nlohmann::detail::value_t rhs) const noexcept
compare two value_t enum values
json_value(array_t &&value)
constructor for rvalue arrays
number_integer_t number_integer
number (integer)
binary_t * binary
binary (stored with pointer to save storage)
json_value(number_integer_t v) noexcept
constructor for numbers (integer)
json_value(const array_t &value)
constructor for arrays
object_t * object
object (stored with pointer to save storage)
json_value(binary_t &&value)
constructor for rvalue binary arrays (internal type)
number_float_t number_float
number (floating-point)
json_value(string_t &&value)
constructor for rvalue strings
number_unsigned_t number_unsigned
number (unsigned integer)
json_value(const object_t &value)
constructor for objects
json_value(const typename binary_t::container_type &value)
constructor for binary arrays
json_value(value_t t)
constructor for empty values of a given type
json_value(boolean_t v) noexcept
constructor for booleans
array_t * array
array (stored with pointer to save storage)
string_t * string
string (stored with pointer to save storage)
json_value(const binary_t &value)
constructor for binary arrays (internal type)
json_value(object_t &&value)
constructor for rvalue objects
json_value()=default
default constructor (for null values)
json_value(typename binary_t::container_type &&value)
constructor for rvalue binary arrays
json_value(const string_t &value)
constructor for strings
json_value(number_float_t v) noexcept
constructor for numbers (floating-point)
json_value(number_unsigned_t v) noexcept
constructor for numbers (unsigned)